Upload original JAVA语言程序设计 course files (part 22)

Java开发环境安装/eclipse-jee-2024-06-R-win32-x86_64/eclipse/plugins/org.eclipse.wildwebdeveloper_1.2.2.202405280856/node_modules/volar-service-html/README.md

@@ -1,3 +1,25 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:59af10ac0d49a529127b274f88b6e43b58c5a7902188ba3bfe6b2322537fbd01
-size 389
+# volar-service-html
+
+Volar plugin for [`vscode-html-languageservice`](https://github.com/microsoft/vscode-html-languageservice).
+
+## Installation
+
+```sh
+npm install volar-service-html
+```
+
+## Usage
+
+`volar.config.js`
+
+```js
+module.exports = {
+	services: [
+		require('volar-service-html').create(),
+	],
+};
+```
+
+## License
+
+[MIT](LICENSE) © [Johnson Chu](https://github.com/johnsoncodehk)

Java开发环境安装/eclipse-jee-2024-06-R-win32-x86_64/eclipse/plugins/org.eclipse.wildwebdeveloper_1.2.2.202405280856/node_modules/volar-service-html/node_modules/vscode-html-languageservice/LICENSE.md

@@ -1,3 +1,21 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:c3a24c02d678e5f0711623dcf3ab3f243b273c2633f638a1fa8e35fb7c7f8e4d
-size 1092
+The MIT License (MIT)
+
+Copyright (c) Microsoft
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

Java开发环境安装/eclipse-jee-2024-06-R-win32-x86_64/eclipse/plugins/org.eclipse.wildwebdeveloper_1.2.2.202405280856/node_modules/volar-service-html/node_modules/vscode-html-languageservice/README.md

@@ -1,3 +1,69 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:e856292613701611e5ed2bc8833ca457af6901dab5eb340e93eadf7d2b828c0b
-size 3397
+# vscode-html-languageservice
+HTML language service extracted from VSCode to be reused, e.g in the Monaco editor.
+
+[![npm Package](https://img.shields.io/npm/v/vscode-html-languageservice.svg?style=flat-square)](https://www.npmjs.org/package/vscode-html-languageservice)
+[![NPM Downloads](https://img.shields.io/npm/dm/vscode-html-languageservice.svg)](https://npmjs.org/package/vscode-html-languageservice)
+[![Build Status](https://github.com/microsoft/vscode-html-languageservice/actions/workflows/node.js.yml/badge.svg)](https://github.com/microsoft/vscode-html-languageservice/actions)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+Why?
+----
+
+The _vscode-html-languageservice_ contains the language smarts behind the HTML editing experience of Visual Studio Code
+and the Monaco editor.
+
+ - *doComplete* / *doComplete2* (async) provide completion proposals for a given location.
+ - *setCompletionParticipants* allows participant to provide suggestions for specific tokens.
+ - *doHover* provides hover information at a given location.
+
+ - *format* formats the code at the given range.
+ - *findDocumentLinks* finds all links in the document.
+ - *findDocumentSymbols* finds all the symbols in the document.
+ - *getFoldingRanges* return folding ranges for the given document.
+ - *getSelectionRanges* return the selection ranges for the given document.
+ ...
+
+ For the complete API see [htmlLanguageService.ts](./src/htmlLanguageService.ts) and [htmlLanguageTypes.ts](./src/htmlLanguageTypes.ts)
+
+Installation
+------------
+
+    npm install --save vscode-html-languageservice
+
+Development
+-----------
+
+- clone this repo, run `npm i``
+- `npm test` to compile and run tests
+
+
+How can I run and debug the service?
+
+- open the folder in VSCode.
+- set breakpoints, e.g. in `htmlCompletion.ts`
+- run the Unit tests from the run viewlet and wait until a breakpoint is hit:
+![image](https://user-images.githubusercontent.com/6461412/94239202-bdad4e80-ff11-11ea-99c3-cb9dbeb1c0b2.png)
+
+
+How can I run and debug the service inside an instance of VSCode?
+
+- run VSCode out of sources setup as described here: https://github.com/Microsoft/vscode/wiki/How-to-Contribute
+- link the folder of the `vscode-html-languageservice` repo to `vscode/extensions/html-language-features/server` to run VSCode with the latest changes from that folder:
+  - cd `vscode-html-languageservice`, `npm link`
+  - cd `vscode/extensions/html-language-features/server`, `npm link vscode-html-languageservice`
+- run VSCode out of source (`vscode/scripts/code.sh|bat`) and open a `.html` file
+- in VSCode window that is open on the `vscode-html-languageservice` sources, run command `Debug: Attach to Node process` and pick the `code-oss` process with the `html-language-features` path
+![image](https://user-images.githubusercontent.com/6461412/94239296-dfa6d100-ff11-11ea-8e30-6444cf5defb8.png)
+- set breakpoints, e.g. in `htmlCompletion.ts`
+- in the instance run from sources, invoke code completion in the `.html` file
+
+
+License
+-------
+
+(MIT License)
+
+Copyright 2016-2023, Microsoft
+
+`src/languageFacts/data/webCustomData.ts` (shipped as `lib/esm/languageFacts/data/webCustomData.ts` and `lib/umd/languageFacts/data/webCustomData.ts`)
+are built upon content from [Mozilla Developer Network](https://developer.mozilla.org/en-US/docs/Web) and distributed under CC BY-SA 2.5.

Java开发环境安装/eclipse-jee-2024-06-R-win32-x86_64/eclipse/plugins/org.eclipse.wildwebdeveloper_1.2.2.202405280856/node_modules/volar-service-html/node_modules/vscode-html-languageservice/SECURITY.md

@@ -1,3 +1,41 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:430987b8c5f30c366ecd501bc344c8b29b6280e8a10174376a769f7443a187cd
-size 2757
+<!-- BEGIN MICROSOFT SECURITY.MD V0.0.8 BLOCK -->
+
+## Security
+
+Microsoft takes the security of our software products and services seriously, which includes all source code repositories managed through our GitHub organizations, which include [Microsoft](https://github.com/microsoft), [Azure](https://github.com/Azure), [DotNet](https://github.com/dotnet), [AspNet](https://github.com/aspnet), [Xamarin](https://github.com/xamarin), and [our GitHub organizations](https://opensource.microsoft.com/).
+
+If you believe you have found a security vulnerability in any Microsoft-owned repository that meets [Microsoft's definition of a security vulnerability](https://aka.ms/opensource/security/definition), please report it to us as described below.
+
+## Reporting Security Issues
+
+**Please do not report security vulnerabilities through public GitHub issues.**
+
+Instead, please report them to the Microsoft Security Response Center (MSRC) at [https://msrc.microsoft.com/create-report](https://aka.ms/opensource/security/create-report).
+
+If you prefer to submit without logging in, send email to [secure@microsoft.com](mailto:secure@microsoft.com).  If possible, encrypt your message with our PGP key; please download it from the [Microsoft Security Response Center PGP Key page](https://aka.ms/opensource/security/pgpkey).
+
+You should receive a response within 24 hours. If for some reason you do not, please follow up via email to ensure we received your original message. Additional information can be found at [microsoft.com/msrc](https://aka.ms/opensource/security/msrc). 
+
+Please include the requested information listed below (as much as you can provide) to help us better understand the nature and scope of the possible issue:
+
+  * Type of issue (e.g. buffer overflow, SQL injection, cross-site scripting, etc.)
+  * Full paths of source file(s) related to the manifestation of the issue
+  * The location of the affected source code (tag/branch/commit or direct URL)
+  * Any special configuration required to reproduce the issue
+  * Step-by-step instructions to reproduce the issue
+  * Proof-of-concept or exploit code (if possible)
+  * Impact of the issue, including how an attacker might exploit the issue
+
+This information will help us triage your report more quickly.
+
+If you are reporting for a bug bounty, more complete reports can contribute to a higher bounty award. Please visit our [Microsoft Bug Bounty Program](https://aka.ms/opensource/security/bounty) page for more details about our active programs.
+
+## Preferred Languages
+
+We prefer all communications to be in English.
+
+## Policy
+
+Microsoft follows the principle of [Coordinated Vulnerability Disclosure](https://aka.ms/opensource/security/cvd).
+
+<!-- END MICROSOFT SECURITY.MD BLOCK -->

Java开发环境安装/eclipse-jee-2024-06-R-win32-x86_64/eclipse/plugins/org.eclipse.wildwebdeveloper_1.2.2.202405280856/node_modules/volar-service-html/node_modules/vscode-html-languageservice/lib/esm/beautify/beautify-css.js

@@ -1,3 +1,1672 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:9c1741621c6a9c1a91942e4d6bc149351bbb1919aad34afaf3e7cc7e9b881dbc
-size 53584
+// copied from js-beautify/js/lib/beautify-css.js
+// version: 1.15.1
+/* AUTO-GENERATED. DO NOT MODIFY. */
+/*
+
+  The MIT License (MIT)
+
+  Copyright (c) 2007-2018 Einar Lielmanis, Liam Newman, and contributors.
+
+  Permission is hereby granted, free of charge, to any person
+  obtaining a copy of this software and associated documentation files
+  (the "Software"), to deal in the Software without restriction,
+  including without limitation the rights to use, copy, modify, merge,
+  publish, distribute, sublicense, and/or sell copies of the Software,
+  and to permit persons to whom the Software is furnished to do so,
+  subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be
+  included in all copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+  BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+  ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+  CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+
+
+ CSS Beautifier
+---------------
+
+    Written by Harutyun Amirjanyan, (amirjanyan@gmail.com)
+
+    Based on code initially developed by: Einar Lielmanis, <einar@beautifier.io>
+        https://beautifier.io/
+
+    Usage:
+        css_beautify(source_text);
+        css_beautify(source_text, options);
+
+    The options are (default in brackets):
+        indent_size (4)                         — indentation size,
+        indent_char (space)                     — character to indent with,
+        selector_separator_newline (true)       - separate selectors with newline or
+                                                  not (e.g. "a,\nbr" or "a, br")
+        end_with_newline (false)                - end with a newline
+        newline_between_rules (true)            - add a new line after every css rule
+        space_around_selector_separator (false) - ensure space around selector separators:
+                                                  '>', '+', '~' (e.g. "a>b" -> "a > b")
+    e.g
+
+    css_beautify(css_source_text, {
+      'indent_size': 1,
+      'indent_char': '\t',
+      'selector_separator': ' ',
+      'end_with_newline': false,
+      'newline_between_rules': true,
+      'space_around_selector_separator': true
+    });
+*/
+
+// http://www.w3.org/TR/CSS21/syndata.html#tokenization
+// http://www.w3.org/TR/css3-syntax/
+
+var legacy_beautify_css;
+/******/ (function() { // webpackBootstrap
+/******/ 	"use strict";
+/******/ 	var __webpack_modules__ = ([
+/* 0 */,
+/* 1 */,
+/* 2 */
+/***/ (function(module) {
+
+/*jshint node:true */
+/*
+  The MIT License (MIT)
+
+  Copyright (c) 2007-2018 Einar Lielmanis, Liam Newman, and contributors.
+
+  Permission is hereby granted, free of charge, to any person
+  obtaining a copy of this software and associated documentation files
+  (the "Software"), to deal in the Software without restriction,
+  including without limitation the rights to use, copy, modify, merge,
+  publish, distribute, sublicense, and/or sell copies of the Software,
+  and to permit persons to whom the Software is furnished to do so,
+  subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be
+  included in all copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+  BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+  ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+  CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+*/
+
+
+
+function OutputLine(parent) {
+  this.__parent = parent;
+  this.__character_count = 0;
+  // use indent_count as a marker for this.__lines that have preserved indentation
+  this.__indent_count = -1;
+  this.__alignment_count = 0;
+  this.__wrap_point_index = 0;
+  this.__wrap_point_character_count = 0;
+  this.__wrap_point_indent_count = -1;
+  this.__wrap_point_alignment_count = 0;
+
+  this.__items = [];
+}
+
+OutputLine.prototype.clone_empty = function() {
+  var line = new OutputLine(this.__parent);
+  line.set_indent(this.__indent_count, this.__alignment_count);
+  return line;
+};
+
+OutputLine.prototype.item = function(index) {
+  if (index < 0) {
+    return this.__items[this.__items.length + index];
+  } else {
+    return this.__items[index];
+  }
+};
+
+OutputLine.prototype.has_match = function(pattern) {
+  for (var lastCheckedOutput = this.__items.length - 1; lastCheckedOutput >= 0; lastCheckedOutput--) {
+    if (this.__items[lastCheckedOutput].match(pattern)) {
+      return true;
+    }
+  }
+  return false;
+};
+
+OutputLine.prototype.set_indent = function(indent, alignment) {
+  if (this.is_empty()) {
+    this.__indent_count = indent || 0;
+    this.__alignment_count = alignment || 0;
+    this.__character_count = this.__parent.get_indent_size(this.__indent_count, this.__alignment_count);
+  }
+};
+
+OutputLine.prototype._set_wrap_point = function() {
+  if (this.__parent.wrap_line_length) {
+    this.__wrap_point_index = this.__items.length;
+    this.__wrap_point_character_count = this.__character_count;
+    this.__wrap_point_indent_count = this.__parent.next_line.__indent_count;
+    this.__wrap_point_alignment_count = this.__parent.next_line.__alignment_count;
+  }
+};
+
+OutputLine.prototype._should_wrap = function() {
+  return this.__wrap_point_index &&
+    this.__character_count > this.__parent.wrap_line_length &&
+    this.__wrap_point_character_count > this.__parent.next_line.__character_count;
+};
+
+OutputLine.prototype._allow_wrap = function() {
+  if (this._should_wrap()) {
+    this.__parent.add_new_line();
+    var next = this.__parent.current_line;
+    next.set_indent(this.__wrap_point_indent_count, this.__wrap_point_alignment_count);
+    next.__items = this.__items.slice(this.__wrap_point_index);
+    this.__items = this.__items.slice(0, this.__wrap_point_index);
+
+    next.__character_count += this.__character_count - this.__wrap_point_character_count;
+    this.__character_count = this.__wrap_point_character_count;
+
+    if (next.__items[0] === " ") {
+      next.__items.splice(0, 1);
+      next.__character_count -= 1;
+    }
+    return true;
+  }
+  return false;
+};
+
+OutputLine.prototype.is_empty = function() {
+  return this.__items.length === 0;
+};
+
+OutputLine.prototype.last = function() {
+  if (!this.is_empty()) {
+    return this.__items[this.__items.length - 1];
+  } else {
+    return null;
+  }
+};
+
+OutputLine.prototype.push = function(item) {
+  this.__items.push(item);
+  var last_newline_index = item.lastIndexOf('\n');
+  if (last_newline_index !== -1) {
+    this.__character_count = item.length - last_newline_index;
+  } else {
+    this.__character_count += item.length;
+  }
+};
+
+OutputLine.prototype.pop = function() {
+  var item = null;
+  if (!this.is_empty()) {
+    item = this.__items.pop();
+    this.__character_count -= item.length;
+  }
+  return item;
+};
+
+
+OutputLine.prototype._remove_indent = function() {
+  if (this.__indent_count > 0) {
+    this.__indent_count -= 1;
+    this.__character_count -= this.__parent.indent_size;
+  }
+};
+
+OutputLine.prototype._remove_wrap_indent = function() {
+  if (this.__wrap_point_indent_count > 0) {
+    this.__wrap_point_indent_count -= 1;
+  }
+};
+OutputLine.prototype.trim = function() {
+  while (this.last() === ' ') {
+    this.__items.pop();
+    this.__character_count -= 1;
+  }
+};
+
+OutputLine.prototype.toString = function() {
+  var result = '';
+  if (this.is_empty()) {
+    if (this.__parent.indent_empty_lines) {
+      result = this.__parent.get_indent_string(this.__indent_count);
+    }
+  } else {
+    result = this.__parent.get_indent_string(this.__indent_count, this.__alignment_count);
+    result += this.__items.join('');
+  }
+  return result;
+};
+
+function IndentStringCache(options, baseIndentString) {
+  this.__cache = [''];
+  this.__indent_size = options.indent_size;
+  this.__indent_string = options.indent_char;
+  if (!options.indent_with_tabs) {
+    this.__indent_string = new Array(options.indent_size + 1).join(options.indent_char);
+  }
+
+  // Set to null to continue support for auto detection of base indent
+  baseIndentString = baseIndentString || '';
+  if (options.indent_level > 0) {
+    baseIndentString = new Array(options.indent_level + 1).join(this.__indent_string);
+  }
+
+  this.__base_string = baseIndentString;
+  this.__base_string_length = baseIndentString.length;
+}
+
+IndentStringCache.prototype.get_indent_size = function(indent, column) {
+  var result = this.__base_string_length;
+  column = column || 0;
+  if (indent < 0) {
+    result = 0;
+  }
+  result += indent * this.__indent_size;
+  result += column;
+  return result;
+};
+
+IndentStringCache.prototype.get_indent_string = function(indent_level, column) {
+  var result = this.__base_string;
+  column = column || 0;
+  if (indent_level < 0) {
+    indent_level = 0;
+    result = '';
+  }
+  column += indent_level * this.__indent_size;
+  this.__ensure_cache(column);
+  result += this.__cache[column];
+  return result;
+};
+
+IndentStringCache.prototype.__ensure_cache = function(column) {
+  while (column >= this.__cache.length) {
+    this.__add_column();
+  }
+};
+
+IndentStringCache.prototype.__add_column = function() {
+  var column = this.__cache.length;
+  var indent = 0;
+  var result = '';
+  if (this.__indent_size && column >= this.__indent_size) {
+    indent = Math.floor(column / this.__indent_size);
+    column -= indent * this.__indent_size;
+    result = new Array(indent + 1).join(this.__indent_string);
+  }
+  if (column) {
+    result += new Array(column + 1).join(' ');
+  }
+
+  this.__cache.push(result);
+};
+
+function Output(options, baseIndentString) {
+  this.__indent_cache = new IndentStringCache(options, baseIndentString);
+  this.raw = false;
+  this._end_with_newline = options.end_with_newline;
+  this.indent_size = options.indent_size;
+  this.wrap_line_length = options.wrap_line_length;
+  this.indent_empty_lines = options.indent_empty_lines;
+  this.__lines = [];
+  this.previous_line = null;
+  this.current_line = null;
+  this.next_line = new OutputLine(this);
+  this.space_before_token = false;
+  this.non_breaking_space = false;
+  this.previous_token_wrapped = false;
+  // initialize
+  this.__add_outputline();
+}
+
+Output.prototype.__add_outputline = function() {
+  this.previous_line = this.current_line;
+  this.current_line = this.next_line.clone_empty();
+  this.__lines.push(this.current_line);
+};
+
+Output.prototype.get_line_number = function() {
+  return this.__lines.length;
+};
+
+Output.prototype.get_indent_string = function(indent, column) {
+  return this.__indent_cache.get_indent_string(indent, column);
+};
+
+Output.prototype.get_indent_size = function(indent, column) {
+  return this.__indent_cache.get_indent_size(indent, column);
+};
+
+Output.prototype.is_empty = function() {
+  return !this.previous_line && this.current_line.is_empty();
+};
+
+Output.prototype.add_new_line = function(force_newline) {
+  // never newline at the start of file
+  // otherwise, newline only if we didn't just add one or we're forced
+  if (this.is_empty() ||
+    (!force_newline && this.just_added_newline())) {
+    return false;
+  }
+
+  // if raw output is enabled, don't print additional newlines,
+  // but still return True as though you had
+  if (!this.raw) {
+    this.__add_outputline();
+  }
+  return true;
+};
+
+Output.prototype.get_code = function(eol) {
+  this.trim(true);
+
+  // handle some edge cases where the last tokens
+  // has text that ends with newline(s)
+  var last_item = this.current_line.pop();
+  if (last_item) {
+    if (last_item[last_item.length - 1] === '\n') {
+      last_item = last_item.replace(/\n+$/g, '');
+    }
+    this.current_line.push(last_item);
+  }
+
+  if (this._end_with_newline) {
+    this.__add_outputline();
+  }
+
+  var sweet_code = this.__lines.join('\n');
+
+  if (eol !== '\n') {
+    sweet_code = sweet_code.replace(/[\n]/g, eol);
+  }
+  return sweet_code;
+};
+
+Output.prototype.set_wrap_point = function() {
+  this.current_line._set_wrap_point();
+};
+
+Output.prototype.set_indent = function(indent, alignment) {
+  indent = indent || 0;
+  alignment = alignment || 0;
+
+  // Next line stores alignment values
+  this.next_line.set_indent(indent, alignment);
+
+  // Never indent your first output indent at the start of the file
+  if (this.__lines.length > 1) {
+    this.current_line.set_indent(indent, alignment);
+    return true;
+  }
+
+  this.current_line.set_indent();
+  return false;
+};
+
+Output.prototype.add_raw_token = function(token) {
+  for (var x = 0; x < token.newlines; x++) {
+    this.__add_outputline();
+  }
+  this.current_line.set_indent(-1);
+  this.current_line.push(token.whitespace_before);
+  this.current_line.push(token.text);
+  this.space_before_token = false;
+  this.non_breaking_space = false;
+  this.previous_token_wrapped = false;
+};
+
+Output.prototype.add_token = function(printable_token) {
+  this.__add_space_before_token();
+  this.current_line.push(printable_token);
+  this.space_before_token = false;
+  this.non_breaking_space = false;
+  this.previous_token_wrapped = this.current_line._allow_wrap();
+};
+
+Output.prototype.__add_space_before_token = function() {
+  if (this.space_before_token && !this.just_added_newline()) {
+    if (!this.non_breaking_space) {
+      this.set_wrap_point();
+    }
+    this.current_line.push(' ');
+  }
+};
+
+Output.prototype.remove_indent = function(index) {
+  var output_length = this.__lines.length;
+  while (index < output_length) {
+    this.__lines[index]._remove_indent();
+    index++;
+  }
+  this.current_line._remove_wrap_indent();
+};
+
+Output.prototype.trim = function(eat_newlines) {
+  eat_newlines = (eat_newlines === undefined) ? false : eat_newlines;
+
+  this.current_line.trim();
+
+  while (eat_newlines && this.__lines.length > 1 &&
+    this.current_line.is_empty()) {
+    this.__lines.pop();
+    this.current_line = this.__lines[this.__lines.length - 1];
+    this.current_line.trim();
+  }
+
+  this.previous_line = this.__lines.length > 1 ?
+    this.__lines[this.__lines.length - 2] : null;
+};
+
+Output.prototype.just_added_newline = function() {
+  return this.current_line.is_empty();
+};
+
+Output.prototype.just_added_blankline = function() {
+  return this.is_empty() ||
+    (this.current_line.is_empty() && this.previous_line.is_empty());
+};
+
+Output.prototype.ensure_empty_line_above = function(starts_with, ends_with) {
+  var index = this.__lines.length - 2;
+  while (index >= 0) {
+    var potentialEmptyLine = this.__lines[index];
+    if (potentialEmptyLine.is_empty()) {
+      break;
+    } else if (potentialEmptyLine.item(0).indexOf(starts_with) !== 0 &&
+      potentialEmptyLine.item(-1) !== ends_with) {
+      this.__lines.splice(index + 1, 0, new OutputLine(this));
+      this.previous_line = this.__lines[this.__lines.length - 2];
+      break;
+    }
+    index--;
+  }
+};
+
+module.exports.Output = Output;
+
+
+/***/ }),
+/* 3 */,
+/* 4 */,
+/* 5 */,
+/* 6 */
+/***/ (function(module) {
+
+/*jshint node:true */
+/*
+
+  The MIT License (MIT)
+
+  Copyright (c) 2007-2018 Einar Lielmanis, Liam Newman, and contributors.
+
+  Permission is hereby granted, free of charge, to any person
+  obtaining a copy of this software and associated documentation files
+  (the "Software"), to deal in the Software without restriction,
+  including without limitation the rights to use, copy, modify, merge,
+  publish, distribute, sublicense, and/or sell copies of the Software,
+  and to permit persons to whom the Software is furnished to do so,
+  subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be
+  included in all copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+  BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+  ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+  CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+*/
+
+
+
+function Options(options, merge_child_field) {
+  this.raw_options = _mergeOpts(options, merge_child_field);
+
+  // Support passing the source text back with no change
+  this.disabled = this._get_boolean('disabled');
+
+  this.eol = this._get_characters('eol', 'auto');
+  this.end_with_newline = this._get_boolean('end_with_newline');
+  this.indent_size = this._get_number('indent_size', 4);
+  this.indent_char = this._get_characters('indent_char', ' ');
+  this.indent_level = this._get_number('indent_level');
+
+  this.preserve_newlines = this._get_boolean('preserve_newlines', true);
+  this.max_preserve_newlines = this._get_number('max_preserve_newlines', 32786);
+  if (!this.preserve_newlines) {
+    this.max_preserve_newlines = 0;
+  }
+
+  this.indent_with_tabs = this._get_boolean('indent_with_tabs', this.indent_char === '\t');
+  if (this.indent_with_tabs) {
+    this.indent_char = '\t';
+
+    // indent_size behavior changed after 1.8.6
+    // It used to be that indent_size would be
+    // set to 1 for indent_with_tabs. That is no longer needed and
+    // actually doesn't make sense - why not use spaces? Further,
+    // that might produce unexpected behavior - tabs being used
+    // for single-column alignment. So, when indent_with_tabs is true
+    // and indent_size is 1, reset indent_size to 4.
+    if (this.indent_size === 1) {
+      this.indent_size = 4;
+    }
+  }
+
+  // Backwards compat with 1.3.x
+  this.wrap_line_length = this._get_number('wrap_line_length', this._get_number('max_char'));
+
+  this.indent_empty_lines = this._get_boolean('indent_empty_lines');
+
+  // valid templating languages ['django', 'erb', 'handlebars', 'php', 'smarty', 'angular']
+  // For now, 'auto' = all off for javascript, all except angular on for html (and inline javascript/css).
+  // other values ignored
+  this.templating = this._get_selection_list('templating', ['auto', 'none', 'angular', 'django', 'erb', 'handlebars', 'php', 'smarty'], ['auto']);
+}
+
+Options.prototype._get_array = function(name, default_value) {
+  var option_value = this.raw_options[name];
+  var result = default_value || [];
+  if (typeof option_value === 'object') {
+    if (option_value !== null && typeof option_value.concat === 'function') {
+      result = option_value.concat();
+    }
+  } else if (typeof option_value === 'string') {
+    result = option_value.split(/[^a-zA-Z0-9_\/\-]+/);
+  }
+  return result;
+};
+
+Options.prototype._get_boolean = function(name, default_value) {
+  var option_value = this.raw_options[name];
+  var result = option_value === undefined ? !!default_value : !!option_value;
+  return result;
+};
+
+Options.prototype._get_characters = function(name, default_value) {
+  var option_value = this.raw_options[name];
+  var result = default_value || '';
+  if (typeof option_value === 'string') {
+    result = option_value.replace(/\\r/, '\r').replace(/\\n/, '\n').replace(/\\t/, '\t');
+  }
+  return result;
+};
+
+Options.prototype._get_number = function(name, default_value) {
+  var option_value = this.raw_options[name];
+  default_value = parseInt(default_value, 10);
+  if (isNaN(default_value)) {
+    default_value = 0;
+  }
+  var result = parseInt(option_value, 10);
+  if (isNaN(result)) {
+    result = default_value;
+  }
+  return result;
+};
+
+Options.prototype._get_selection = function(name, selection_list, default_value) {
+  var result = this._get_selection_list(name, selection_list, default_value);
+  if (result.length !== 1) {
+    throw new Error(
+      "Invalid Option Value: The option '" + name + "' can only be one of the following values:\n" +
+      selection_list + "\nYou passed in: '" + this.raw_options[name] + "'");
+  }
+
+  return result[0];
+};
+
+
+Options.prototype._get_selection_list = function(name, selection_list, default_value) {
+  if (!selection_list || selection_list.length === 0) {
+    throw new Error("Selection list cannot be empty.");
+  }
+
+  default_value = default_value || [selection_list[0]];
+  if (!this._is_valid_selection(default_value, selection_list)) {
+    throw new Error("Invalid Default Value!");
+  }
+
+  var result = this._get_array(name, default_value);
+  if (!this._is_valid_selection(result, selection_list)) {
+    throw new Error(
+      "Invalid Option Value: The option '" + name + "' can contain only the following values:\n" +
+      selection_list + "\nYou passed in: '" + this.raw_options[name] + "'");
+  }
+
+  return result;
+};
+
+Options.prototype._is_valid_selection = function(result, selection_list) {
+  return result.length && selection_list.length &&
+    !result.some(function(item) { return selection_list.indexOf(item) === -1; });
+};
+
+
+// merges child options up with the parent options object
+// Example: obj = {a: 1, b: {a: 2}}
+//          mergeOpts(obj, 'b')
+//
+//          Returns: {a: 2}
+function _mergeOpts(allOptions, childFieldName) {
+  var finalOpts = {};
+  allOptions = _normalizeOpts(allOptions);
+  var name;
+
+  for (name in allOptions) {
+    if (name !== childFieldName) {
+      finalOpts[name] = allOptions[name];
+    }
+  }
+
+  //merge in the per type settings for the childFieldName
+  if (childFieldName && allOptions[childFieldName]) {
+    for (name in allOptions[childFieldName]) {
+      finalOpts[name] = allOptions[childFieldName][name];
+    }
+  }
+  return finalOpts;
+}
+
+function _normalizeOpts(options) {
+  var convertedOpts = {};
+  var key;
+
+  for (key in options) {
+    var newKey = key.replace(/-/g, "_");
+    convertedOpts[newKey] = options[key];
+  }
+  return convertedOpts;
+}
+
+module.exports.Options = Options;
+module.exports.normalizeOpts = _normalizeOpts;
+module.exports.mergeOpts = _mergeOpts;
+
+
+/***/ }),
+/* 7 */,
+/* 8 */
+/***/ (function(module) {
+
+/*jshint node:true */
+/*
+
+  The MIT License (MIT)
+
+  Copyright (c) 2007-2018 Einar Lielmanis, Liam Newman, and contributors.
+
+  Permission is hereby granted, free of charge, to any person
+  obtaining a copy of this software and associated documentation files
+  (the "Software"), to deal in the Software without restriction,
+  including without limitation the rights to use, copy, modify, merge,
+  publish, distribute, sublicense, and/or sell copies of the Software,
+  and to permit persons to whom the Software is furnished to do so,
+  subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be
+  included in all copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+  BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+  ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+  CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+*/
+
+
+
+var regexp_has_sticky = RegExp.prototype.hasOwnProperty('sticky');
+
+function InputScanner(input_string) {
+  this.__input = input_string || '';
+  this.__input_length = this.__input.length;
+  this.__position = 0;
+}
+
+InputScanner.prototype.restart = function() {
+  this.__position = 0;
+};
+
+InputScanner.prototype.back = function() {
+  if (this.__position > 0) {
+    this.__position -= 1;
+  }
+};
+
+InputScanner.prototype.hasNext = function() {
+  return this.__position < this.__input_length;
+};
+
+InputScanner.prototype.next = function() {
+  var val = null;
+  if (this.hasNext()) {
+    val = this.__input.charAt(this.__position);
+    this.__position += 1;
+  }
+  return val;
+};
+
+InputScanner.prototype.peek = function(index) {
+  var val = null;
+  index = index || 0;
+  index += this.__position;
+  if (index >= 0 && index < this.__input_length) {
+    val = this.__input.charAt(index);
+  }
+  return val;
+};
+
+// This is a JavaScript only helper function (not in python)
+// Javascript doesn't have a match method
+// and not all implementation support "sticky" flag.
+// If they do not support sticky then both this.match() and this.test() method
+// must get the match and check the index of the match.
+// If sticky is supported and set, this method will use it.
+// Otherwise it will check that global is set, and fall back to the slower method.
+InputScanner.prototype.__match = function(pattern, index) {
+  pattern.lastIndex = index;
+  var pattern_match = pattern.exec(this.__input);
+
+  if (pattern_match && !(regexp_has_sticky && pattern.sticky)) {
+    if (pattern_match.index !== index) {
+      pattern_match = null;
+    }
+  }
+
+  return pattern_match;
+};
+
+InputScanner.prototype.test = function(pattern, index) {
+  index = index || 0;
+  index += this.__position;
+
+  if (index >= 0 && index < this.__input_length) {
+    return !!this.__match(pattern, index);
+  } else {
+    return false;
+  }
+};
+
+InputScanner.prototype.testChar = function(pattern, index) {
+  // test one character regex match
+  var val = this.peek(index);
+  pattern.lastIndex = 0;
+  return val !== null && pattern.test(val);
+};
+
+InputScanner.prototype.match = function(pattern) {
+  var pattern_match = this.__match(pattern, this.__position);
+  if (pattern_match) {
+    this.__position += pattern_match[0].length;
+  } else {
+    pattern_match = null;
+  }
+  return pattern_match;
+};
+
+InputScanner.prototype.read = function(starting_pattern, until_pattern, until_after) {
+  var val = '';
+  var match;
+  if (starting_pattern) {
+    match = this.match(starting_pattern);
+    if (match) {
+      val += match[0];
+    }
+  }
+  if (until_pattern && (match || !starting_pattern)) {
+    val += this.readUntil(until_pattern, until_after);
+  }
+  return val;
+};
+
+InputScanner.prototype.readUntil = function(pattern, until_after) {
+  var val = '';
+  var match_index = this.__position;
+  pattern.lastIndex = this.__position;
+  var pattern_match = pattern.exec(this.__input);
+  if (pattern_match) {
+    match_index = pattern_match.index;
+    if (until_after) {
+      match_index += pattern_match[0].length;
+    }
+  } else {
+    match_index = this.__input_length;
+  }
+
+  val = this.__input.substring(this.__position, match_index);
+  this.__position = match_index;
+  return val;
+};
+
+InputScanner.prototype.readUntilAfter = function(pattern) {
+  return this.readUntil(pattern, true);
+};
+
+InputScanner.prototype.get_regexp = function(pattern, match_from) {
+  var result = null;
+  var flags = 'g';
+  if (match_from && regexp_has_sticky) {
+    flags = 'y';
+  }
+  // strings are converted to regexp
+  if (typeof pattern === "string" && pattern !== '') {
+    // result = new RegExp(pattern.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&'), flags);
+    result = new RegExp(pattern, flags);
+  } else if (pattern) {
+    result = new RegExp(pattern.source, flags);
+  }
+  return result;
+};
+
+InputScanner.prototype.get_literal_regexp = function(literal_string) {
+  return RegExp(literal_string.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&'));
+};
+
+/* css beautifier legacy helpers */
+InputScanner.prototype.peekUntilAfter = function(pattern) {
+  var start = this.__position;
+  var val = this.readUntilAfter(pattern);
+  this.__position = start;
+  return val;
+};
+
+InputScanner.prototype.lookBack = function(testVal) {
+  var start = this.__position - 1;
+  return start >= testVal.length && this.__input.substring(start - testVal.length, start)
+    .toLowerCase() === testVal;
+};
+
+module.exports.InputScanner = InputScanner;
+
+
+/***/ }),
+/* 9 */,
+/* 10 */,
+/* 11 */,
+/* 12 */,
+/* 13 */
+/***/ (function(module) {
+
+/*jshint node:true */
+/*
+
+  The MIT License (MIT)
+
+  Copyright (c) 2007-2018 Einar Lielmanis, Liam Newman, and contributors.
+
+  Permission is hereby granted, free of charge, to any person
+  obtaining a copy of this software and associated documentation files
+  (the "Software"), to deal in the Software without restriction,
+  including without limitation the rights to use, copy, modify, merge,
+  publish, distribute, sublicense, and/or sell copies of the Software,
+  and to permit persons to whom the Software is furnished to do so,
+  subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be
+  included in all copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+  BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+  ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+  CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+*/
+
+
+
+function Directives(start_block_pattern, end_block_pattern) {
+  start_block_pattern = typeof start_block_pattern === 'string' ? start_block_pattern : start_block_pattern.source;
+  end_block_pattern = typeof end_block_pattern === 'string' ? end_block_pattern : end_block_pattern.source;
+  this.__directives_block_pattern = new RegExp(start_block_pattern + / beautify( \w+[:]\w+)+ /.source + end_block_pattern, 'g');
+  this.__directive_pattern = / (\w+)[:](\w+)/g;
+
+  this.__directives_end_ignore_pattern = new RegExp(start_block_pattern + /\sbeautify\signore:end\s/.source + end_block_pattern, 'g');
+}
+
+Directives.prototype.get_directives = function(text) {
+  if (!text.match(this.__directives_block_pattern)) {
+    return null;
+  }
+
+  var directives = {};
+  this.__directive_pattern.lastIndex = 0;
+  var directive_match = this.__directive_pattern.exec(text);
+
+  while (directive_match) {
+    directives[directive_match[1]] = directive_match[2];
+    directive_match = this.__directive_pattern.exec(text);
+  }
+
+  return directives;
+};
+
+Directives.prototype.readIgnored = function(input) {
+  return input.readUntilAfter(this.__directives_end_ignore_pattern);
+};
+
+
+module.exports.Directives = Directives;
+
+
+/***/ }),
+/* 14 */,
+/* 15 */
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+/*jshint node:true */
+/*
+
+  The MIT License (MIT)
+
+  Copyright (c) 2007-2018 Einar Lielmanis, Liam Newman, and contributors.
+
+  Permission is hereby granted, free of charge, to any person
+  obtaining a copy of this software and associated documentation files
+  (the "Software"), to deal in the Software without restriction,
+  including without limitation the rights to use, copy, modify, merge,
+  publish, distribute, sublicense, and/or sell copies of the Software,
+  and to permit persons to whom the Software is furnished to do so,
+  subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be
+  included in all copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+  BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+  ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+  CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+*/
+
+
+
+var Beautifier = (__webpack_require__(16).Beautifier),
+  Options = (__webpack_require__(17).Options);
+
+function css_beautify(source_text, options) {
+  var beautifier = new Beautifier(source_text, options);
+  return beautifier.beautify();
+}
+
+module.exports = css_beautify;
+module.exports.defaultOptions = function() {
+  return new Options();
+};
+
+
+/***/ }),
+/* 16 */
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+/*jshint node:true */
+/*
+
+  The MIT License (MIT)
+
+  Copyright (c) 2007-2018 Einar Lielmanis, Liam Newman, and contributors.
+
+  Permission is hereby granted, free of charge, to any person
+  obtaining a copy of this software and associated documentation files
+  (the "Software"), to deal in the Software without restriction,
+  including without limitation the rights to use, copy, modify, merge,
+  publish, distribute, sublicense, and/or sell copies of the Software,
+  and to permit persons to whom the Software is furnished to do so,
+  subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be
+  included in all copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+  BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+  ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+  CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+*/
+
+
+
+var Options = (__webpack_require__(17).Options);
+var Output = (__webpack_require__(2).Output);
+var InputScanner = (__webpack_require__(8).InputScanner);
+var Directives = (__webpack_require__(13).Directives);
+
+var directives_core = new Directives(/\/\*/, /\*\//);
+
+var lineBreak = /\r\n|[\r\n]/;
+var allLineBreaks = /\r\n|[\r\n]/g;
+
+// tokenizer
+var whitespaceChar = /\s/;
+var whitespacePattern = /(?:\s|\n)+/g;
+var block_comment_pattern = /\/\*(?:[\s\S]*?)((?:\*\/)|$)/g;
+var comment_pattern = /\/\/(?:[^\n\r\u2028\u2029]*)/g;
+
+function Beautifier(source_text, options) {
+  this._source_text = source_text || '';
+  // Allow the setting of language/file-type specific options
+  // with inheritance of overall settings
+  this._options = new Options(options);
+  this._ch = null;
+  this._input = null;
+
+  // https://developer.mozilla.org/en-US/docs/Web/CSS/At-rule
+  this.NESTED_AT_RULE = {
+    "page": true,
+    "font-face": true,
+    "keyframes": true,
+    // also in CONDITIONAL_GROUP_RULE below
+    "media": true,
+    "supports": true,
+    "document": true
+  };
+  this.CONDITIONAL_GROUP_RULE = {
+    "media": true,
+    "supports": true,
+    "document": true
+  };
+  this.NON_SEMICOLON_NEWLINE_PROPERTY = [
+    "grid-template-areas",
+    "grid-template"
+  ];
+
+}
+
+Beautifier.prototype.eatString = function(endChars) {
+  var result = '';
+  this._ch = this._input.next();
+  while (this._ch) {
+    result += this._ch;
+    if (this._ch === "\\") {
+      result += this._input.next();
+    } else if (endChars.indexOf(this._ch) !== -1 || this._ch === "\n") {
+      break;
+    }
+    this._ch = this._input.next();
+  }
+  return result;
+};
+
+// Skips any white space in the source text from the current position.
+// When allowAtLeastOneNewLine is true, will output new lines for each
+// newline character found; if the user has preserve_newlines off, only
+// the first newline will be output
+Beautifier.prototype.eatWhitespace = function(allowAtLeastOneNewLine) {
+  var result = whitespaceChar.test(this._input.peek());
+  var newline_count = 0;
+  while (whitespaceChar.test(this._input.peek())) {
+    this._ch = this._input.next();
+    if (allowAtLeastOneNewLine && this._ch === '\n') {
+      if (newline_count === 0 || newline_count < this._options.max_preserve_newlines) {
+        newline_count++;
+        this._output.add_new_line(true);
+      }
+    }
+  }
+  return result;
+};
+
+// Nested pseudo-class if we are insideRule
+// and the next special character found opens
+// a new block
+Beautifier.prototype.foundNestedPseudoClass = function() {
+  var openParen = 0;
+  var i = 1;
+  var ch = this._input.peek(i);
+  while (ch) {
+    if (ch === "{") {
+      return true;
+    } else if (ch === '(') {
+      // pseudoclasses can contain ()
+      openParen += 1;
+    } else if (ch === ')') {
+      if (openParen === 0) {
+        return false;
+      }
+      openParen -= 1;
+    } else if (ch === ";" || ch === "}") {
+      return false;
+    }
+    i++;
+    ch = this._input.peek(i);
+  }
+  return false;
+};
+
+Beautifier.prototype.print_string = function(output_string) {
+  this._output.set_indent(this._indentLevel);
+  this._output.non_breaking_space = true;
+  this._output.add_token(output_string);
+};
+
+Beautifier.prototype.preserveSingleSpace = function(isAfterSpace) {
+  if (isAfterSpace) {
+    this._output.space_before_token = true;
+  }
+};
+
+Beautifier.prototype.indent = function() {
+  this._indentLevel++;
+};
+
+Beautifier.prototype.outdent = function() {
+  if (this._indentLevel > 0) {
+    this._indentLevel--;
+  }
+};
+
+/*_____________________--------------------_____________________*/
+
+Beautifier.prototype.beautify = function() {
+  if (this._options.disabled) {
+    return this._source_text;
+  }
+
+  var source_text = this._source_text;
+  var eol = this._options.eol;
+  if (eol === 'auto') {
+    eol = '\n';
+    if (source_text && lineBreak.test(source_text || '')) {
+      eol = source_text.match(lineBreak)[0];
+    }
+  }
+
+
+  // HACK: newline parsing inconsistent. This brute force normalizes the this._input.
+  source_text = source_text.replace(allLineBreaks, '\n');
+
+  // reset
+  var baseIndentString = source_text.match(/^[\t ]*/)[0];
+
+  this._output = new Output(this._options, baseIndentString);
+  this._input = new InputScanner(source_text);
+  this._indentLevel = 0;
+  this._nestedLevel = 0;
+
+  this._ch = null;
+  var parenLevel = 0;
+
+  var insideRule = false;
+  // This is the value side of a property value pair (blue in the following ex)
+  // label { content: blue }
+  var insidePropertyValue = false;
+  var enteringConditionalGroup = false;
+  var insideNonNestedAtRule = false;
+  var insideScssMap = false;
+  var topCharacter = this._ch;
+  var insideNonSemiColonValues = false;
+  var whitespace;
+  var isAfterSpace;
+  var previous_ch;
+
+  while (true) {
+    whitespace = this._input.read(whitespacePattern);
+    isAfterSpace = whitespace !== '';
+    previous_ch = topCharacter;
+    this._ch = this._input.next();
+    if (this._ch === '\\' && this._input.hasNext()) {
+      this._ch += this._input.next();
+    }
+    topCharacter = this._ch;
+
+    if (!this._ch) {
+      break;
+    } else if (this._ch === '/' && this._input.peek() === '*') {
+      // /* css comment */
+      // Always start block comments on a new line.
+      // This handles scenarios where a block comment immediately
+      // follows a property definition on the same line or where
+      // minified code is being beautified.
+      this._output.add_new_line();
+      this._input.back();
+
+      var comment = this._input.read(block_comment_pattern);
+
+      // Handle ignore directive
+      var directives = directives_core.get_directives(comment);
+      if (directives && directives.ignore === 'start') {
+        comment += directives_core.readIgnored(this._input);
+      }
+
+      this.print_string(comment);
+
+      // Ensures any new lines following the comment are preserved
+      this.eatWhitespace(true);
+
+      // Block comments are followed by a new line so they don't
+      // share a line with other properties
+      this._output.add_new_line();
+    } else if (this._ch === '/' && this._input.peek() === '/') {
+      // // single line comment
+      // Preserves the space before a comment
+      // on the same line as a rule
+      this._output.space_before_token = true;
+      this._input.back();
+      this.print_string(this._input.read(comment_pattern));
+
+      // Ensures any new lines following the comment are preserved
+      this.eatWhitespace(true);
+    } else if (this._ch === '$') {
+      this.preserveSingleSpace(isAfterSpace);
+
+      this.print_string(this._ch);
+
+      // strip trailing space, if present, for hash property checks
+      var variable = this._input.peekUntilAfter(/[: ,;{}()[\]\/='"]/g);
+
+      if (variable.match(/[ :]$/)) {
+        // we have a variable or pseudo-class, add it and insert one space before continuing
+        variable = this.eatString(": ").replace(/\s+$/, '');
+        this.print_string(variable);
+        this._output.space_before_token = true;
+      }
+
+      // might be sass variable
+      if (parenLevel === 0 && variable.indexOf(':') !== -1) {
+        insidePropertyValue = true;
+        this.indent();
+      }
+    } else if (this._ch === '@') {
+      this.preserveSingleSpace(isAfterSpace);
+
+      // deal with less property mixins @{...}
+      if (this._input.peek() === '{') {
+        this.print_string(this._ch + this.eatString('}'));
+      } else {
+        this.print_string(this._ch);
+
+        // strip trailing space, if present, for hash property checks
+        var variableOrRule = this._input.peekUntilAfter(/[: ,;{}()[\]\/='"]/g);
+
+        if (variableOrRule.match(/[ :]$/)) {
+          // we have a variable or pseudo-class, add it and insert one space before continuing
+          variableOrRule = this.eatString(": ").replace(/\s+$/, '');
+          this.print_string(variableOrRule);
+          this._output.space_before_token = true;
+        }
+
+        // might be less variable
+        if (parenLevel === 0 && variableOrRule.indexOf(':') !== -1) {
+          insidePropertyValue = true;
+          this.indent();
+
+          // might be a nesting at-rule
+        } else if (variableOrRule in this.NESTED_AT_RULE) {
+          this._nestedLevel += 1;
+          if (variableOrRule in this.CONDITIONAL_GROUP_RULE) {
+            enteringConditionalGroup = true;
+          }
+
+          // might be a non-nested at-rule
+        } else if (parenLevel === 0 && !insidePropertyValue) {
+          insideNonNestedAtRule = true;
+        }
+      }
+    } else if (this._ch === '#' && this._input.peek() === '{') {
+      this.preserveSingleSpace(isAfterSpace);
+      this.print_string(this._ch + this.eatString('}'));
+    } else if (this._ch === '{') {
+      if (insidePropertyValue) {
+        insidePropertyValue = false;
+        this.outdent();
+      }
+
+      // non nested at rule becomes nested
+      insideNonNestedAtRule = false;
+
+      // when entering conditional groups, only rulesets are allowed
+      if (enteringConditionalGroup) {
+        enteringConditionalGroup = false;
+        insideRule = (this._indentLevel >= this._nestedLevel);
+      } else {
+        // otherwise, declarations are also allowed
+        insideRule = (this._indentLevel >= this._nestedLevel - 1);
+      }
+      if (this._options.newline_between_rules && insideRule) {
+        if (this._output.previous_line && this._output.previous_line.item(-1) !== '{') {
+          this._output.ensure_empty_line_above('/', ',');
+        }
+      }
+
+      this._output.space_before_token = true;
+
+      // The difference in print_string and indent order is necessary to indent the '{' correctly
+      if (this._options.brace_style === 'expand') {
+        this._output.add_new_line();
+        this.print_string(this._ch);
+        this.indent();
+        this._output.set_indent(this._indentLevel);
+      } else {
+        // inside mixin and first param is object
+        if (previous_ch === '(') {
+          this._output.space_before_token = false;
+        } else if (previous_ch !== ',') {
+          this.indent();
+        }
+        this.print_string(this._ch);
+      }
+
+      this.eatWhitespace(true);
+      this._output.add_new_line();
+    } else if (this._ch === '}') {
+      this.outdent();
+      this._output.add_new_line();
+      if (previous_ch === '{') {
+        this._output.trim(true);
+      }
+
+      if (insidePropertyValue) {
+        this.outdent();
+        insidePropertyValue = false;
+      }
+      this.print_string(this._ch);
+      insideRule = false;
+      if (this._nestedLevel) {
+        this._nestedLevel--;
+      }
+
+      this.eatWhitespace(true);
+      this._output.add_new_line();
+
+      if (this._options.newline_between_rules && !this._output.just_added_blankline()) {
+        if (this._input.peek() !== '}') {
+          this._output.add_new_line(true);
+        }
+      }
+      if (this._input.peek() === ')') {
+        this._output.trim(true);
+        if (this._options.brace_style === "expand") {
+          this._output.add_new_line(true);
+        }
+      }
+    } else if (this._ch === ":") {
+
+      for (var i = 0; i < this.NON_SEMICOLON_NEWLINE_PROPERTY.length; i++) {
+        if (this._input.lookBack(this.NON_SEMICOLON_NEWLINE_PROPERTY[i])) {
+          insideNonSemiColonValues = true;
+          break;
+        }
+      }
+
+      if ((insideRule || enteringConditionalGroup) && !(this._input.lookBack("&") || this.foundNestedPseudoClass()) && !this._input.lookBack("(") && !insideNonNestedAtRule && parenLevel === 0) {
+        // 'property: value' delimiter
+        // which could be in a conditional group query
+
+        this.print_string(':');
+        if (!insidePropertyValue) {
+          insidePropertyValue = true;
+          this._output.space_before_token = true;
+          this.eatWhitespace(true);
+          this.indent();
+        }
+      } else {
+        // sass/less parent reference don't use a space
+        // sass nested pseudo-class don't use a space
+
+        // preserve space before pseudoclasses/pseudoelements, as it means "in any child"
+        if (this._input.lookBack(" ")) {
+          this._output.space_before_token = true;
+        }
+        if (this._input.peek() === ":") {
+          // pseudo-element
+          this._ch = this._input.next();
+          this.print_string("::");
+        } else {
+          // pseudo-class
+          this.print_string(':');
+        }
+      }
+    } else if (this._ch === '"' || this._ch === '\'') {
+      var preserveQuoteSpace = previous_ch === '"' || previous_ch === '\'';
+      this.preserveSingleSpace(preserveQuoteSpace || isAfterSpace);
+      this.print_string(this._ch + this.eatString(this._ch));
+      this.eatWhitespace(true);
+    } else if (this._ch === ';') {
+      insideNonSemiColonValues = false;
+      if (parenLevel === 0) {
+        if (insidePropertyValue) {
+          this.outdent();
+          insidePropertyValue = false;
+        }
+        insideNonNestedAtRule = false;
+        this.print_string(this._ch);
+        this.eatWhitespace(true);
+
+        // This maintains single line comments on the same
+        // line. Block comments are also affected, but
+        // a new line is always output before one inside
+        // that section
+        if (this._input.peek() !== '/') {
+          this._output.add_new_line();
+        }
+      } else {
+        this.print_string(this._ch);
+        this.eatWhitespace(true);
+        this._output.space_before_token = true;
+      }
+    } else if (this._ch === '(') { // may be a url
+      if (this._input.lookBack("url")) {
+        this.print_string(this._ch);
+        this.eatWhitespace();
+        parenLevel++;
+        this.indent();
+        this._ch = this._input.next();
+        if (this._ch === ')' || this._ch === '"' || this._ch === '\'') {
+          this._input.back();
+        } else if (this._ch) {
+          this.print_string(this._ch + this.eatString(')'));
+          if (parenLevel) {
+            parenLevel--;
+            this.outdent();
+          }
+        }
+      } else {
+        var space_needed = false;
+        if (this._input.lookBack("with")) {
+          // look back is not an accurate solution, we need tokens to confirm without whitespaces
+          space_needed = true;
+        }
+        this.preserveSingleSpace(isAfterSpace || space_needed);
+        this.print_string(this._ch);
+
+        // handle scss/sass map
+        if (insidePropertyValue && previous_ch === "$" && this._options.selector_separator_newline) {
+          this._output.add_new_line();
+          insideScssMap = true;
+        } else {
+          this.eatWhitespace();
+          parenLevel++;
+          this.indent();
+        }
+      }
+    } else if (this._ch === ')') {
+      if (parenLevel) {
+        parenLevel--;
+        this.outdent();
+      }
+      if (insideScssMap && this._input.peek() === ";" && this._options.selector_separator_newline) {
+        insideScssMap = false;
+        this.outdent();
+        this._output.add_new_line();
+      }
+      this.print_string(this._ch);
+    } else if (this._ch === ',') {
+      this.print_string(this._ch);
+      this.eatWhitespace(true);
+      if (this._options.selector_separator_newline && (!insidePropertyValue || insideScssMap) && parenLevel === 0 && !insideNonNestedAtRule) {
+        this._output.add_new_line();
+      } else {
+        this._output.space_before_token = true;
+      }
+    } else if ((this._ch === '>' || this._ch === '+' || this._ch === '~') && !insidePropertyValue && parenLevel === 0) {
+      //handle combinator spacing
+      if (this._options.space_around_combinator) {
+        this._output.space_before_token = true;
+        this.print_string(this._ch);
+        this._output.space_before_token = true;
+      } else {
+        this.print_string(this._ch);
+        this.eatWhitespace();
+        // squash extra whitespace
+        if (this._ch && whitespaceChar.test(this._ch)) {
+          this._ch = '';
+        }
+      }
+    } else if (this._ch === ']') {
+      this.print_string(this._ch);
+    } else if (this._ch === '[') {
+      this.preserveSingleSpace(isAfterSpace);
+      this.print_string(this._ch);
+    } else if (this._ch === '=') { // no whitespace before or after
+      this.eatWhitespace();
+      this.print_string('=');
+      if (whitespaceChar.test(this._ch)) {
+        this._ch = '';
+      }
+    } else if (this._ch === '!' && !this._input.lookBack("\\")) { // !important
+      this._output.space_before_token = true;
+      this.print_string(this._ch);
+    } else {
+      var preserveAfterSpace = previous_ch === '"' || previous_ch === '\'';
+      this.preserveSingleSpace(preserveAfterSpace || isAfterSpace);
+      this.print_string(this._ch);
+
+      if (!this._output.just_added_newline() && this._input.peek() === '\n' && insideNonSemiColonValues) {
+        this._output.add_new_line();
+      }
+    }
+  }
+
+  var sweetCode = this._output.get_code(eol);
+
+  return sweetCode;
+};
+
+module.exports.Beautifier = Beautifier;
+
+
+/***/ }),
+/* 17 */
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+/*jshint node:true */
+/*
+
+  The MIT License (MIT)
+
+  Copyright (c) 2007-2018 Einar Lielmanis, Liam Newman, and contributors.
+
+  Permission is hereby granted, free of charge, to any person
+  obtaining a copy of this software and associated documentation files
+  (the "Software"), to deal in the Software without restriction,
+  including without limitation the rights to use, copy, modify, merge,
+  publish, distribute, sublicense, and/or sell copies of the Software,
+  and to permit persons to whom the Software is furnished to do so,
+  subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be
+  included in all copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+  BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+  ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+  CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+*/
+
+
+
+var BaseOptions = (__webpack_require__(6).Options);
+
+function Options(options) {
+  BaseOptions.call(this, options, 'css');
+
+  this.selector_separator_newline = this._get_boolean('selector_separator_newline', true);
+  this.newline_between_rules = this._get_boolean('newline_between_rules', true);
+  var space_around_selector_separator = this._get_boolean('space_around_selector_separator');
+  this.space_around_combinator = this._get_boolean('space_around_combinator') || space_around_selector_separator;
+
+  var brace_style_split = this._get_selection_list('brace_style', ['collapse', 'expand', 'end-expand', 'none', 'preserve-inline']);
+  this.brace_style = 'collapse';
+  for (var bs = 0; bs < brace_style_split.length; bs++) {
+    if (brace_style_split[bs] !== 'expand') {
+      // default to collapse, as only collapse|expand is implemented for now
+      this.brace_style = 'collapse';
+    } else {
+      this.brace_style = brace_style_split[bs];
+    }
+  }
+}
+Options.prototype = new BaseOptions();
+
+
+
+module.exports.Options = Options;
+
+
+/***/ })
+/******/ 	]);
+/************************************************************************/
+/******/ 	// The module cache
+/******/ 	var __webpack_module_cache__ = {};
+/******/ 	
+/******/ 	// The require function
+/******/ 	function __webpack_require__(moduleId) {
+/******/ 		// Check if module is in cache
+/******/ 		var cachedModule = __webpack_module_cache__[moduleId];
+/******/ 		if (cachedModule !== undefined) {
+/******/ 			return cachedModule.exports;
+/******/ 		}
+/******/ 		// Create a new module (and put it into the cache)
+/******/ 		var module = __webpack_module_cache__[moduleId] = {
+/******/ 			// no module.id needed
+/******/ 			// no module.loaded needed
+/******/ 			exports: {}
+/******/ 		};
+/******/ 	
+/******/ 		// Execute the module function
+/******/ 		__webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+/******/ 	
+/******/ 		// Return the exports of the module
+/******/ 		return module.exports;
+/******/ 	}
+/******/ 	
+/************************************************************************/
+/******/ 	
+/******/ 	// startup
+/******/ 	// Load entry module and return exports
+/******/ 	// This entry module is referenced by other modules so it can't be inlined
+/******/ 	var __webpack_exports__ = __webpack_require__(15);
+/******/ 	legacy_beautify_css = __webpack_exports__;
+/******/ 	
+/******/ })()
+;
+
+export var css_beautify = legacy_beautify_css;

Java开发环境安装/eclipse-jee-2024-06-R-win32-x86_64/eclipse/plugins/org.eclipse.wildwebdeveloper_1.2.2.202405280856/node_modules/volar-service-html/node_modules/vscode-html-languageservice/lib/esm/beautify/beautify.js

@@ -1,3 +1,11 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:eb15186bfa69bf4a5a1a98e911c9d47157c5b3600ac775b4ff6868d8f5c0533d
-size 535
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+/*
+ * Mock for the JS formatter. Ignore formatting of JS content in HTML.
+ */
+export function js_beautify(js_source_text, options) {
+    // no formatting
+    return js_source_text;
+}

Java开发环境安装/eclipse-jee-2024-06-R-win32-x86_64/eclipse/plugins/org.eclipse.wildwebdeveloper_1.2.2.202405280856/node_modules/volar-service-html/node_modules/vscode-html-languageservice/lib/esm/htmlLanguageService.d.ts

@@ -1,3 +1,30 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:8044ec1977fdea7750c43309c60f2ee8aeab66616631a13e811559370bed57de
-size 3018
+import { Scanner, HTMLDocument, CompletionConfiguration, ICompletionParticipant, HTMLFormatConfiguration, DocumentContext, DocumentSymbol, IHTMLDataProvider, HTMLDataV1, LanguageServiceOptions, TextDocument, SelectionRange, WorkspaceEdit, Position, CompletionList, Hover, Range, SymbolInformation, TextEdit, DocumentHighlight, DocumentLink, FoldingRange, HoverSettings } from './htmlLanguageTypes';
+export * from './htmlLanguageTypes';
+export interface LanguageService {
+    setDataProviders(useDefaultDataProvider: boolean, customDataProviders: IHTMLDataProvider[]): void;
+    createScanner(input: string, initialOffset?: number): Scanner;
+    parseHTMLDocument(document: TextDocument): HTMLDocument;
+    findDocumentHighlights(document: TextDocument, position: Position, htmlDocument: HTMLDocument): DocumentHighlight[];
+    doComplete(document: TextDocument, position: Position, htmlDocument: HTMLDocument, options?: CompletionConfiguration): CompletionList;
+    doComplete2(document: TextDocument, position: Position, htmlDocument: HTMLDocument, documentContext: DocumentContext, options?: CompletionConfiguration): Promise<CompletionList>;
+    setCompletionParticipants(registeredCompletionParticipants: ICompletionParticipant[]): void;
+    doHover(document: TextDocument, position: Position, htmlDocument: HTMLDocument, options?: HoverSettings): Hover | null;
+    format(document: TextDocument, range: Range | undefined, options: HTMLFormatConfiguration): TextEdit[];
+    findDocumentLinks(document: TextDocument, documentContext: DocumentContext): DocumentLink[];
+    findDocumentSymbols(document: TextDocument, htmlDocument: HTMLDocument): SymbolInformation[];
+    findDocumentSymbols2(document: TextDocument, htmlDocument: HTMLDocument): DocumentSymbol[];
+    doQuoteComplete(document: TextDocument, position: Position, htmlDocument: HTMLDocument, options?: CompletionConfiguration): string | null;
+    doTagComplete(document: TextDocument, position: Position, htmlDocument: HTMLDocument): string | null;
+    getFoldingRanges(document: TextDocument, context?: {
+        rangeLimit?: number;
+    }): FoldingRange[];
+    getSelectionRanges(document: TextDocument, positions: Position[]): SelectionRange[];
+    doRename(document: TextDocument, position: Position, newName: string, htmlDocument: HTMLDocument): WorkspaceEdit | null;
+    findMatchingTagPosition(document: TextDocument, position: Position, htmlDocument: HTMLDocument): Position | null;
+    /** Deprecated, Use findLinkedEditingRanges instead */
+    findOnTypeRenameRanges(document: TextDocument, position: Position, htmlDocument: HTMLDocument): Range[] | null;
+    findLinkedEditingRanges(document: TextDocument, position: Position, htmlDocument: HTMLDocument): Range[] | null;
+}
+export declare function getLanguageService(options?: LanguageServiceOptions): LanguageService;
+export declare function newHTMLDataProvider(id: string, customData: HTMLDataV1): IHTMLDataProvider;
+export declare function getDefaultHTMLDataProvider(): IHTMLDataProvider;

Java开发环境安装/eclipse-jee-2024-06-R-win32-x86_64/eclipse/plugins/org.eclipse.wildwebdeveloper_1.2.2.202405280856/node_modules/volar-service-html/node_modules/vscode-html-languageservice/lib/esm/htmlLanguageService.js

@@ -1,3 +1,59 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:f70f33f096580ed21f317ec2c6015b221e3acbf645539195ab0ef2a6be6bb226
-size 3265
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import { createScanner } from './parser/htmlScanner';
+import { HTMLParser } from './parser/htmlParser';
+import { HTMLCompletion } from './services/htmlCompletion';
+import { HTMLHover } from './services/htmlHover';
+import { format } from './services/htmlFormatter';
+import { HTMLDocumentLinks } from './services/htmlLinks';
+import { findDocumentHighlights } from './services/htmlHighlighting';
+import { findDocumentSymbols, findDocumentSymbols2 } from './services/htmlSymbolsProvider';
+import { doRename } from './services/htmlRename';
+import { findMatchingTagPosition } from './services/htmlMatchingTagPosition';
+import { findLinkedEditingRanges } from './services/htmlLinkedEditing';
+import { HTMLFolding } from './services/htmlFolding';
+import { HTMLSelectionRange } from './services/htmlSelectionRange';
+import { HTMLDataProvider } from './languageFacts/dataProvider';
+import { HTMLDataManager } from './languageFacts/dataManager';
+import { htmlData } from './languageFacts/data/webCustomData';
+export * from './htmlLanguageTypes';
+const defaultLanguageServiceOptions = {};
+export function getLanguageService(options = defaultLanguageServiceOptions) {
+    const dataManager = new HTMLDataManager(options);
+    const htmlHover = new HTMLHover(options, dataManager);
+    const htmlCompletion = new HTMLCompletion(options, dataManager);
+    const htmlParser = new HTMLParser(dataManager);
+    const htmlSelectionRange = new HTMLSelectionRange(htmlParser);
+    const htmlFolding = new HTMLFolding(dataManager);
+    const htmlDocumentLinks = new HTMLDocumentLinks(dataManager);
+    return {
+        setDataProviders: dataManager.setDataProviders.bind(dataManager),
+        createScanner,
+        parseHTMLDocument: htmlParser.parseDocument.bind(htmlParser),
+        doComplete: htmlCompletion.doComplete.bind(htmlCompletion),
+        doComplete2: htmlCompletion.doComplete2.bind(htmlCompletion),
+        setCompletionParticipants: htmlCompletion.setCompletionParticipants.bind(htmlCompletion),
+        doHover: htmlHover.doHover.bind(htmlHover),
+        format,
+        findDocumentHighlights,
+        findDocumentLinks: htmlDocumentLinks.findDocumentLinks.bind(htmlDocumentLinks),
+        findDocumentSymbols,
+        findDocumentSymbols2,
+        getFoldingRanges: htmlFolding.getFoldingRanges.bind(htmlFolding),
+        getSelectionRanges: htmlSelectionRange.getSelectionRanges.bind(htmlSelectionRange),
+        doQuoteComplete: htmlCompletion.doQuoteComplete.bind(htmlCompletion),
+        doTagComplete: htmlCompletion.doTagComplete.bind(htmlCompletion),
+        doRename,
+        findMatchingTagPosition,
+        findOnTypeRenameRanges: findLinkedEditingRanges,
+        findLinkedEditingRanges
+    };
+}
+export function newHTMLDataProvider(id, customData) {
+    return new HTMLDataProvider(id, customData);
+}
+export function getDefaultHTMLDataProvider() {
+    return newHTMLDataProvider('default', htmlData);
+}

Java开发环境安装/eclipse-jee-2024-06-R-win32-x86_64/eclipse/plugins/org.eclipse.wildwebdeveloper_1.2.2.202405280856/node_modules/volar-service-html/node_modules/vscode-html-languageservice/lib/esm/htmlLanguageTypes.d.ts

@@ -1,3 +1,256 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:7f5b0f6aad8f3ff0736fa295c721b27f16d974f511221d8b6954cb2a91d49970
-size 8083
+import { Position, Range, Location, MarkupContent, MarkupKind, MarkedString, DocumentUri, SelectionRange, WorkspaceEdit, CompletionList, CompletionItemKind, CompletionItem, CompletionItemTag, InsertTextMode, Command, SymbolInformation, DocumentSymbol, SymbolKind, Hover, TextEdit, InsertReplaceEdit, InsertTextFormat, DocumentHighlight, DocumentHighlightKind, DocumentLink, FoldingRange, FoldingRangeKind, SignatureHelp, Definition, Diagnostic, FormattingOptions, Color, ColorInformation, ColorPresentation } from 'vscode-languageserver-types';
+import { TextDocument } from 'vscode-languageserver-textdocument';
+export { TextDocument, Position, Range, Location, MarkupContent, MarkupKind, MarkedString, DocumentUri, SelectionRange, WorkspaceEdit, CompletionList, CompletionItemKind, CompletionItem, CompletionItemTag, InsertTextMode, Command, SymbolInformation, DocumentSymbol, SymbolKind, Hover, TextEdit, InsertReplaceEdit, InsertTextFormat, DocumentHighlight, DocumentHighlightKind, DocumentLink, FoldingRange, FoldingRangeKind, SignatureHelp, Definition, Diagnostic, FormattingOptions, Color, ColorInformation, ColorPresentation };
+export interface HTMLFormatConfiguration {
+    tabSize?: number;
+    insertSpaces?: boolean;
+    indentEmptyLines?: boolean;
+    wrapLineLength?: number;
+    unformatted?: string;
+    contentUnformatted?: string;
+    indentInnerHtml?: boolean;
+    wrapAttributes?: 'auto' | 'force' | 'force-aligned' | 'force-expand-multiline' | 'aligned-multiple' | 'preserve' | 'preserve-aligned';
+    wrapAttributesIndentSize?: number;
+    preserveNewLines?: boolean;
+    maxPreserveNewLines?: number;
+    indentHandlebars?: boolean;
+    endWithNewline?: boolean;
+    extraLiners?: string;
+    indentScripts?: 'keep' | 'separate' | 'normal';
+    templating?: ('auto' | 'none' | 'angular' | 'django' | 'erb' | 'handlebars' | 'php' | 'smarty')[] | boolean;
+    unformattedContentDelimiter?: string;
+}
+export interface HoverSettings {
+    documentation?: boolean;
+    references?: boolean;
+}
+export interface CompletionConfiguration {
+    [provider: string]: boolean | undefined | string;
+    hideAutoCompleteProposals?: boolean;
+    attributeDefaultValue?: 'empty' | 'singlequotes' | 'doublequotes';
+}
+export interface Node {
+    tag: string | undefined;
+    start: number;
+    startTagEnd: number | undefined;
+    end: number;
+    endTagStart: number | undefined;
+    children: Node[];
+    parent?: Node;
+    attributes?: {
+        [name: string]: string | null;
+    } | undefined;
+}
+export declare enum TokenType {
+    StartCommentTag = 0,
+    Comment = 1,
+    EndCommentTag = 2,
+    StartTagOpen = 3,
+    StartTagClose = 4,
+    StartTagSelfClose = 5,
+    StartTag = 6,
+    EndTagOpen = 7,
+    EndTagClose = 8,
+    EndTag = 9,
+    DelimiterAssign = 10,
+    AttributeName = 11,
+    AttributeValue = 12,
+    StartDoctypeTag = 13,
+    Doctype = 14,
+    EndDoctypeTag = 15,
+    Content = 16,
+    Whitespace = 17,
+    Unknown = 18,
+    Script = 19,
+    Styles = 20,
+    EOS = 21
+}
+export declare enum ScannerState {
+    WithinContent = 0,
+    AfterOpeningStartTag = 1,
+    AfterOpeningEndTag = 2,
+    WithinDoctype = 3,
+    WithinTag = 4,
+    WithinEndTag = 5,
+    WithinComment = 6,
+    WithinScriptContent = 7,
+    WithinStyleContent = 8,
+    AfterAttributeName = 9,
+    BeforeAttributeValue = 10
+}
+export interface Scanner {
+    scan(): TokenType;
+    getTokenType(): TokenType;
+    getTokenOffset(): number;
+    getTokenLength(): number;
+    getTokenEnd(): number;
+    getTokenText(): string;
+    getTokenError(): string | undefined;
+    getScannerState(): ScannerState;
+}
+export declare type HTMLDocument = {
+    roots: Node[];
+    findNodeBefore(offset: number): Node;
+    findNodeAt(offset: number): Node;
+};
+export interface DocumentContext {
+    resolveReference(ref: string, base: string): string | undefined;
+}
+export interface HtmlAttributeValueContext {
+    document: TextDocument;
+    position: Position;
+    tag: string;
+    attribute: string;
+    value: string;
+    range: Range;
+}
+export interface HtmlContentContext {
+    document: TextDocument;
+    position: Position;
+}
+export interface ICompletionParticipant {
+    onHtmlAttributeValue?: (context: HtmlAttributeValueContext) => void;
+    onHtmlContent?: (context: HtmlContentContext) => void;
+}
+export interface IReference {
+    name: string;
+    url: string;
+}
+export interface ITagData {
+    name: string;
+    description?: string | MarkupContent;
+    attributes: IAttributeData[];
+    references?: IReference[];
+    void?: boolean;
+}
+export interface IAttributeData {
+    name: string;
+    description?: string | MarkupContent;
+    valueSet?: string;
+    values?: IValueData[];
+    references?: IReference[];
+}
+export interface IValueData {
+    name: string;
+    description?: string | MarkupContent;
+    references?: IReference[];
+}
+export interface IValueSet {
+    name: string;
+    values: IValueData[];
+}
+export interface HTMLDataV1 {
+    version: 1 | 1.1;
+    tags?: ITagData[];
+    globalAttributes?: IAttributeData[];
+    valueSets?: IValueSet[];
+}
+export interface IHTMLDataProvider {
+    getId(): string;
+    isApplicable(languageId: string): boolean;
+    provideTags(): ITagData[];
+    provideAttributes(tag: string): IAttributeData[];
+    provideValues(tag: string, attribute: string): IValueData[];
+}
+/**
+ * Describes what LSP capabilities the client supports
+ */
+export interface ClientCapabilities {
+    /**
+     * The text document client capabilities
+     */
+    textDocument?: {
+        /**
+         * Capabilities specific to completions.
+         */
+        completion?: {
+            /**
+             * The client supports the following `CompletionItem` specific
+             * capabilities.
+             */
+            completionItem?: {
+                /**
+                 * Client supports the follow content formats for the documentation
+                 * property. The order describes the preferred format of the client.
+                 */
+                documentationFormat?: MarkupKind[];
+            };
+        };
+        /**
+         * Capabilities specific to hovers.
+         */
+        hover?: {
+            /**
+             * Client supports the follow content formats for the content
+             * property. The order describes the preferred format of the client.
+             */
+            contentFormat?: MarkupKind[];
+        };
+    };
+}
+export declare namespace ClientCapabilities {
+    const LATEST: ClientCapabilities;
+}
+export interface LanguageServiceOptions {
+    /**
+     * Unless set to false, the default HTML data provider will be used
+     * along with the providers from customDataProviders.
+     * Defaults to true.
+     */
+    useDefaultDataProvider?: boolean;
+    /**
+     * Provide data that could enhance the service's understanding of
+     * HTML tag / attribute / attribute-value
+     */
+    customDataProviders?: IHTMLDataProvider[];
+    /**
+     * Abstract file system access away from the service.
+     * Used for path completion, etc.
+     */
+    fileSystemProvider?: FileSystemProvider;
+    /**
+     * Describes the LSP capabilities the client supports.
+     */
+    clientCapabilities?: ClientCapabilities;
+}
+export declare enum FileType {
+    /**
+     * The file type is unknown.
+     */
+    Unknown = 0,
+    /**
+     * A regular file.
+     */
+    File = 1,
+    /**
+     * A directory.
+     */
+    Directory = 2,
+    /**
+     * A symbolic link to a file.
+     */
+    SymbolicLink = 64
+}
+export interface FileStat {
+    /**
+     * The type of the file, e.g. is a regular file, a directory, or symbolic link
+     * to a file.
+     */
+    type: FileType;
+    /**
+     * The creation timestamp in milliseconds elapsed since January 1, 1970 00:00:00 UTC.
+     */
+    ctime: number;
+    /**
+     * The modification timestamp in milliseconds elapsed since January 1, 1970 00:00:00 UTC.
+     */
+    mtime: number;
+    /**
+     * The size in bytes.
+     */
+    size: number;
+}
+export interface FileSystemProvider {
+    stat(uri: DocumentUri): Promise<FileStat>;
+    readDirectory?(uri: DocumentUri): Promise<[string, FileType][]>;
+}

Java开发环境安装/eclipse-jee-2024-06-R-win32-x86_64/eclipse/plugins/org.eclipse.wildwebdeveloper_1.2.2.202405280856/node_modules/volar-service-html/node_modules/vscode-html-languageservice/lib/esm/htmlLanguageTypes.js

@@ -1,3 +1,80 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:1e2a76ffc216e1f4e541597d774249e38035d0cef1476c4823b41c646567d2df
-size 4720
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import { Position, Range, Location, MarkupContent, MarkupKind, MarkedString, DocumentUri, SelectionRange, WorkspaceEdit, CompletionList, CompletionItemKind, CompletionItem, CompletionItemTag, InsertTextMode, Command, SymbolInformation, DocumentSymbol, SymbolKind, Hover, TextEdit, InsertReplaceEdit, InsertTextFormat, DocumentHighlight, DocumentHighlightKind, DocumentLink, FoldingRange, FoldingRangeKind, Diagnostic, FormattingOptions, Color, ColorInformation, ColorPresentation } from 'vscode-languageserver-types';
+import { TextDocument } from 'vscode-languageserver-textdocument';
+export { TextDocument, Position, Range, Location, MarkupContent, MarkupKind, MarkedString, DocumentUri, SelectionRange, WorkspaceEdit, CompletionList, CompletionItemKind, CompletionItem, CompletionItemTag, InsertTextMode, Command, SymbolInformation, DocumentSymbol, SymbolKind, Hover, TextEdit, InsertReplaceEdit, InsertTextFormat, DocumentHighlight, DocumentHighlightKind, DocumentLink, FoldingRange, FoldingRangeKind, Diagnostic, FormattingOptions, Color, ColorInformation, ColorPresentation };
+export var TokenType;
+(function (TokenType) {
+    TokenType[TokenType["StartCommentTag"] = 0] = "StartCommentTag";
+    TokenType[TokenType["Comment"] = 1] = "Comment";
+    TokenType[TokenType["EndCommentTag"] = 2] = "EndCommentTag";
+    TokenType[TokenType["StartTagOpen"] = 3] = "StartTagOpen";
+    TokenType[TokenType["StartTagClose"] = 4] = "StartTagClose";
+    TokenType[TokenType["StartTagSelfClose"] = 5] = "StartTagSelfClose";
+    TokenType[TokenType["StartTag"] = 6] = "StartTag";
+    TokenType[TokenType["EndTagOpen"] = 7] = "EndTagOpen";
+    TokenType[TokenType["EndTagClose"] = 8] = "EndTagClose";
+    TokenType[TokenType["EndTag"] = 9] = "EndTag";
+    TokenType[TokenType["DelimiterAssign"] = 10] = "DelimiterAssign";
+    TokenType[TokenType["AttributeName"] = 11] = "AttributeName";
+    TokenType[TokenType["AttributeValue"] = 12] = "AttributeValue";
+    TokenType[TokenType["StartDoctypeTag"] = 13] = "StartDoctypeTag";
+    TokenType[TokenType["Doctype"] = 14] = "Doctype";
+    TokenType[TokenType["EndDoctypeTag"] = 15] = "EndDoctypeTag";
+    TokenType[TokenType["Content"] = 16] = "Content";
+    TokenType[TokenType["Whitespace"] = 17] = "Whitespace";
+    TokenType[TokenType["Unknown"] = 18] = "Unknown";
+    TokenType[TokenType["Script"] = 19] = "Script";
+    TokenType[TokenType["Styles"] = 20] = "Styles";
+    TokenType[TokenType["EOS"] = 21] = "EOS";
+})(TokenType || (TokenType = {}));
+export var ScannerState;
+(function (ScannerState) {
+    ScannerState[ScannerState["WithinContent"] = 0] = "WithinContent";
+    ScannerState[ScannerState["AfterOpeningStartTag"] = 1] = "AfterOpeningStartTag";
+    ScannerState[ScannerState["AfterOpeningEndTag"] = 2] = "AfterOpeningEndTag";
+    ScannerState[ScannerState["WithinDoctype"] = 3] = "WithinDoctype";
+    ScannerState[ScannerState["WithinTag"] = 4] = "WithinTag";
+    ScannerState[ScannerState["WithinEndTag"] = 5] = "WithinEndTag";
+    ScannerState[ScannerState["WithinComment"] = 6] = "WithinComment";
+    ScannerState[ScannerState["WithinScriptContent"] = 7] = "WithinScriptContent";
+    ScannerState[ScannerState["WithinStyleContent"] = 8] = "WithinStyleContent";
+    ScannerState[ScannerState["AfterAttributeName"] = 9] = "AfterAttributeName";
+    ScannerState[ScannerState["BeforeAttributeValue"] = 10] = "BeforeAttributeValue";
+})(ScannerState || (ScannerState = {}));
+export var ClientCapabilities;
+(function (ClientCapabilities) {
+    ClientCapabilities.LATEST = {
+        textDocument: {
+            completion: {
+                completionItem: {
+                    documentationFormat: [MarkupKind.Markdown, MarkupKind.PlainText]
+                }
+            },
+            hover: {
+                contentFormat: [MarkupKind.Markdown, MarkupKind.PlainText]
+            }
+        }
+    };
+})(ClientCapabilities || (ClientCapabilities = {}));
+export var FileType;
+(function (FileType) {
+    /**
+     * The file type is unknown.
+     */
+    FileType[FileType["Unknown"] = 0] = "Unknown";
+    /**
+     * A regular file.
+     */
+    FileType[FileType["File"] = 1] = "File";
+    /**
+     * A directory.
+     */
+    FileType[FileType["Directory"] = 2] = "Directory";
+    /**
+     * A symbolic link to a file.
+     */
+    FileType[FileType["SymbolicLink"] = 64] = "SymbolicLink";
+})(FileType || (FileType = {}));

Java开发环境安装/eclipse-jee-2024-06-R-win32-x86_64/eclipse/plugins/org.eclipse.wildwebdeveloper_1.2.2.202405280856/node_modules/volar-service-html/node_modules/vscode-html-languageservice/lib/esm/languageFacts/data/webCustomData.d.ts

@@ -1,3 +1,2 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:4915df6340f6cd0cd6aa8765179ae2e0fcee11a6b1936d31638ddba74226f2fe
-size 97
+import { HTMLDataV1 } from '../../htmlLanguageTypes';
+export declare const htmlData: HTMLDataV1;

Java开发环境安装/eclipse-jee-2024-06-R-win32-x86_64/eclipse/plugins/org.eclipse.wildwebdeveloper_1.2.2.202405280856/node_modules/volar-service-html/node_modules/vscode-html-languageservice/lib/esm/languageFacts/dataManager.js

@@ -1,3 +1,77 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:7cc943cbec7ddbbbbf1a1c79250c24e039bdc1209ac34b87d05952213a46cc0e
-size 2624
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import { HTMLDataProvider } from './dataProvider';
+import { htmlData } from './data/webCustomData';
+import * as arrays from '../utils/arrays';
+export class HTMLDataManager {
+    constructor(options) {
+        this.dataProviders = [];
+        this.setDataProviders(options.useDefaultDataProvider !== false, options.customDataProviders || []);
+    }
+    setDataProviders(builtIn, providers) {
+        this.dataProviders = [];
+        if (builtIn) {
+            this.dataProviders.push(new HTMLDataProvider('html5', htmlData));
+        }
+        this.dataProviders.push(...providers);
+    }
+    getDataProviders() {
+        return this.dataProviders;
+    }
+    isVoidElement(e, voidElements) {
+        return !!e && arrays.binarySearch(voidElements, e.toLowerCase(), (s1, s2) => s1.localeCompare(s2)) >= 0;
+    }
+    getVoidElements(languageOrProviders) {
+        const dataProviders = Array.isArray(languageOrProviders) ? languageOrProviders : this.getDataProviders().filter(p => p.isApplicable(languageOrProviders));
+        const voidTags = [];
+        dataProviders.forEach((provider) => {
+            provider.provideTags().filter(tag => tag.void).forEach(tag => voidTags.push(tag.name));
+        });
+        return voidTags.sort();
+    }
+    isPathAttribute(tag, attr) {
+        // should eventually come from custom data
+        if (attr === 'src' || attr === 'href') {
+            return true;
+        }
+        const a = PATH_TAG_AND_ATTR[tag];
+        if (a) {
+            if (typeof a === 'string') {
+                return a === attr;
+            }
+            else {
+                return a.indexOf(attr) !== -1;
+            }
+        }
+        return false;
+    }
+}
+// Selected from https://stackoverflow.com/a/2725168/1780148
+const PATH_TAG_AND_ATTR = {
+    // HTML 4
+    a: 'href',
+    area: 'href',
+    body: 'background',
+    blockquote: 'cite',
+    del: 'cite',
+    form: 'action',
+    frame: ['src', 'longdesc'],
+    img: ['src', 'longdesc'],
+    ins: 'cite',
+    link: 'href',
+    object: 'data',
+    q: 'cite',
+    script: 'src',
+    // HTML 5
+    audio: 'src',
+    button: 'formaction',
+    command: 'icon',
+    embed: 'src',
+    html: 'manifest',
+    input: ['src', 'formaction'],
+    source: 'src',
+    track: 'src',
+    video: ['src', 'poster']
+};

Java开发环境安装/eclipse-jee-2024-06-R-win32-x86_64/eclipse/plugins/org.eclipse.wildwebdeveloper_1.2.2.202405280856/node_modules/volar-service-html/node_modules/vscode-html-languageservice/lib/esm/languageFacts/dataProvider.js

@@ -1,3 +1,112 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:5d4d7f4c4af5132ba6e10e82c04042f0eb824a647160e6dc2f7532f856b471ab
-size 3856
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import { normalizeMarkupContent } from '../utils/markup';
+export class HTMLDataProvider {
+    isApplicable() {
+        return true;
+    }
+    /**
+     * Currently, unversioned data uses the V1 implementation
+     * In the future when the provider handles multiple versions of HTML custom data,
+     * use the latest implementation for unversioned data
+     */
+    constructor(id, customData) {
+        this.id = id;
+        this._tags = [];
+        this._tagMap = {};
+        this._valueSetMap = {};
+        this._tags = customData.tags || [];
+        this._globalAttributes = customData.globalAttributes || [];
+        this._tags.forEach(t => {
+            this._tagMap[t.name.toLowerCase()] = t;
+        });
+        if (customData.valueSets) {
+            customData.valueSets.forEach(vs => {
+                this._valueSetMap[vs.name] = vs.values;
+            });
+        }
+    }
+    getId() {
+        return this.id;
+    }
+    provideTags() {
+        return this._tags;
+    }
+    provideAttributes(tag) {
+        const attributes = [];
+        const processAttribute = (a) => {
+            attributes.push(a);
+        };
+        const tagEntry = this._tagMap[tag.toLowerCase()];
+        if (tagEntry) {
+            tagEntry.attributes.forEach(processAttribute);
+        }
+        this._globalAttributes.forEach(processAttribute);
+        return attributes;
+    }
+    provideValues(tag, attribute) {
+        const values = [];
+        attribute = attribute.toLowerCase();
+        const processAttributes = (attributes) => {
+            attributes.forEach(a => {
+                if (a.name.toLowerCase() === attribute) {
+                    if (a.values) {
+                        a.values.forEach(v => {
+                            values.push(v);
+                        });
+                    }
+                    if (a.valueSet) {
+                        if (this._valueSetMap[a.valueSet]) {
+                            this._valueSetMap[a.valueSet].forEach(v => {
+                                values.push(v);
+                            });
+                        }
+                    }
+                }
+            });
+        };
+        const tagEntry = this._tagMap[tag.toLowerCase()];
+        if (tagEntry) {
+            processAttributes(tagEntry.attributes);
+        }
+        processAttributes(this._globalAttributes);
+        return values;
+    }
+}
+/**
+ * Generate Documentation used in hover/complete
+ * From `documentation` and `references`
+ */
+export function generateDocumentation(item, settings = {}, doesSupportMarkdown) {
+    const result = {
+        kind: doesSupportMarkdown ? 'markdown' : 'plaintext',
+        value: ''
+    };
+    if (item.description && settings.documentation !== false) {
+        const normalizedDescription = normalizeMarkupContent(item.description);
+        if (normalizedDescription) {
+            result.value += normalizedDescription.value;
+        }
+    }
+    if (item.references && item.references.length > 0 && settings.references !== false) {
+        if (result.value.length) {
+            result.value += `\n\n`;
+        }
+        if (doesSupportMarkdown) {
+            result.value += item.references.map(r => {
+                return `[${r.name}](${r.url})`;
+            }).join(' | ');
+        }
+        else {
+            result.value += item.references.map(r => {
+                return `${r.name}: ${r.url}`;
+            }).join('\n');
+        }
+    }
+    if (result.value === '') {
+        return undefined;
+    }
+    return result;
+}

Java开发环境安装/eclipse-jee-2024-06-R-win32-x86_64/eclipse/plugins/org.eclipse.wildwebdeveloper_1.2.2.202405280856/node_modules/volar-service-html/node_modules/vscode-html-languageservice/lib/esm/parser/htmlEntities.js

@@ -1,3 +1,2241 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:b63943ffae4a23ca0bdc1e8f73d6bc597b18afe54fa7ea3b4007932423358c28
-size 58642
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+/**
+ * HTML 5 character entities
+ * https://www.w3.org/TR/html5/syntax.html#named-character-references
+ */
+export const entities = {
+    "Aacute;": "\u00C1",
+    "Aacute": "\u00C1",
+    "aacute;": "\u00E1",
+    "aacute": "\u00E1",
+    "Abreve;": "\u0102",
+    "abreve;": "\u0103",
+    "ac;": "\u223E",
+    "acd;": "\u223F",
+    "acE;": "\u223E\u0333",
+    "Acirc;": "\u00C2",
+    "Acirc": "\u00C2",
+    "acirc;": "\u00E2",
+    "acirc": "\u00E2",
+    "acute;": "\u00B4",
+    "acute": "\u00B4",
+    "Acy;": "\u0410",
+    "acy;": "\u0430",
+    "AElig;": "\u00C6",
+    "AElig": "\u00C6",
+    "aelig;": "\u00E6",
+    "aelig": "\u00E6",
+    "af;": "\u2061",
+    "Afr;": "\uD835\uDD04",
+    "afr;": "\uD835\uDD1E",
+    "Agrave;": "\u00C0",
+    "Agrave": "\u00C0",
+    "agrave;": "\u00E0",
+    "agrave": "\u00E0",
+    "alefsym;": "\u2135",
+    "aleph;": "\u2135",
+    "Alpha;": "\u0391",
+    "alpha;": "\u03B1",
+    "Amacr;": "\u0100",
+    "amacr;": "\u0101",
+    "amalg;": "\u2A3F",
+    "AMP;": "\u0026",
+    "AMP": "\u0026",
+    "amp;": "\u0026",
+    "amp": "\u0026",
+    "And;": "\u2A53",
+    "and;": "\u2227",
+    "andand;": "\u2A55",
+    "andd;": "\u2A5C",
+    "andslope;": "\u2A58",
+    "andv;": "\u2A5A",
+    "ang;": "\u2220",
+    "ange;": "\u29A4",
+    "angle;": "\u2220",
+    "angmsd;": "\u2221",
+    "angmsdaa;": "\u29A8",
+    "angmsdab;": "\u29A9",
+    "angmsdac;": "\u29AA",
+    "angmsdad;": "\u29AB",
+    "angmsdae;": "\u29AC",
+    "angmsdaf;": "\u29AD",
+    "angmsdag;": "\u29AE",
+    "angmsdah;": "\u29AF",
+    "angrt;": "\u221F",
+    "angrtvb;": "\u22BE",
+    "angrtvbd;": "\u299D",
+    "angsph;": "\u2222",
+    "angst;": "\u00C5",
+    "angzarr;": "\u237C",
+    "Aogon;": "\u0104",
+    "aogon;": "\u0105",
+    "Aopf;": "\uD835\uDD38",
+    "aopf;": "\uD835\uDD52",
+    "ap;": "\u2248",
+    "apacir;": "\u2A6F",
+    "apE;": "\u2A70",
+    "ape;": "\u224A",
+    "apid;": "\u224B",
+    "apos;": "\u0027",
+    "ApplyFunction;": "\u2061",
+    "approx;": "\u2248",
+    "approxeq;": "\u224A",
+    "Aring;": "\u00C5",
+    "Aring": "\u00C5",
+    "aring;": "\u00E5",
+    "aring": "\u00E5",
+    "Ascr;": "\uD835\uDC9C",
+    "ascr;": "\uD835\uDCB6",
+    "Assign;": "\u2254",
+    "ast;": "\u002A",
+    "asymp;": "\u2248",
+    "asympeq;": "\u224D",
+    "Atilde;": "\u00C3",
+    "Atilde": "\u00C3",
+    "atilde;": "\u00E3",
+    "atilde": "\u00E3",
+    "Auml;": "\u00C4",
+    "Auml": "\u00C4",
+    "auml;": "\u00E4",
+    "auml": "\u00E4",
+    "awconint;": "\u2233",
+    "awint;": "\u2A11",
+    "backcong;": "\u224C",
+    "backepsilon;": "\u03F6",
+    "backprime;": "\u2035",
+    "backsim;": "\u223D",
+    "backsimeq;": "\u22CD",
+    "Backslash;": "\u2216",
+    "Barv;": "\u2AE7",
+    "barvee;": "\u22BD",
+    "Barwed;": "\u2306",
+    "barwed;": "\u2305",
+    "barwedge;": "\u2305",
+    "bbrk;": "\u23B5",
+    "bbrktbrk;": "\u23B6",
+    "bcong;": "\u224C",
+    "Bcy;": "\u0411",
+    "bcy;": "\u0431",
+    "bdquo;": "\u201E",
+    "becaus;": "\u2235",
+    "Because;": "\u2235",
+    "because;": "\u2235",
+    "bemptyv;": "\u29B0",
+    "bepsi;": "\u03F6",
+    "bernou;": "\u212C",
+    "Bernoullis;": "\u212C",
+    "Beta;": "\u0392",
+    "beta;": "\u03B2",
+    "beth;": "\u2136",
+    "between;": "\u226C",
+    "Bfr;": "\uD835\uDD05",
+    "bfr;": "\uD835\uDD1F",
+    "bigcap;": "\u22C2",
+    "bigcirc;": "\u25EF",
+    "bigcup;": "\u22C3",
+    "bigodot;": "\u2A00",
+    "bigoplus;": "\u2A01",
+    "bigotimes;": "\u2A02",
+    "bigsqcup;": "\u2A06",
+    "bigstar;": "\u2605",
+    "bigtriangledown;": "\u25BD",
+    "bigtriangleup;": "\u25B3",
+    "biguplus;": "\u2A04",
+    "bigvee;": "\u22C1",
+    "bigwedge;": "\u22C0",
+    "bkarow;": "\u290D",
+    "blacklozenge;": "\u29EB",
+    "blacksquare;": "\u25AA",
+    "blacktriangle;": "\u25B4",
+    "blacktriangledown;": "\u25BE",
+    "blacktriangleleft;": "\u25C2",
+    "blacktriangleright;": "\u25B8",
+    "blank;": "\u2423",
+    "blk12;": "\u2592",
+    "blk14;": "\u2591",
+    "blk34;": "\u2593",
+    "block;": "\u2588",
+    "bne;": "\u003D\u20E5",
+    "bnequiv;": "\u2261\u20E5",
+    "bNot;": "\u2AED",
+    "bnot;": "\u2310",
+    "Bopf;": "\uD835\uDD39",
+    "bopf;": "\uD835\uDD53",
+    "bot;": "\u22A5",
+    "bottom;": "\u22A5",
+    "bowtie;": "\u22C8",
+    "boxbox;": "\u29C9",
+    "boxDL;": "\u2557",
+    "boxDl;": "\u2556",
+    "boxdL;": "\u2555",
+    "boxdl;": "\u2510",
+    "boxDR;": "\u2554",
+    "boxDr;": "\u2553",
+    "boxdR;": "\u2552",
+    "boxdr;": "\u250C",
+    "boxH;": "\u2550",
+    "boxh;": "\u2500",
+    "boxHD;": "\u2566",
+    "boxHd;": "\u2564",
+    "boxhD;": "\u2565",
+    "boxhd;": "\u252C",
+    "boxHU;": "\u2569",
+    "boxHu;": "\u2567",
+    "boxhU;": "\u2568",
+    "boxhu;": "\u2534",
+    "boxminus;": "\u229F",
+    "boxplus;": "\u229E",
+    "boxtimes;": "\u22A0",
+    "boxUL;": "\u255D",
+    "boxUl;": "\u255C",
+    "boxuL;": "\u255B",
+    "boxul;": "\u2518",
+    "boxUR;": "\u255A",
+    "boxUr;": "\u2559",
+    "boxuR;": "\u2558",
+    "boxur;": "\u2514",
+    "boxV;": "\u2551",
+    "boxv;": "\u2502",
+    "boxVH;": "\u256C",
+    "boxVh;": "\u256B",
+    "boxvH;": "\u256A",
+    "boxvh;": "\u253C",
+    "boxVL;": "\u2563",
+    "boxVl;": "\u2562",
+    "boxvL;": "\u2561",
+    "boxvl;": "\u2524",
+    "boxVR;": "\u2560",
+    "boxVr;": "\u255F",
+    "boxvR;": "\u255E",
+    "boxvr;": "\u251C",
+    "bprime;": "\u2035",
+    "Breve;": "\u02D8",
+    "breve;": "\u02D8",
+    "brvbar;": "\u00A6",
+    "brvbar": "\u00A6",
+    "Bscr;": "\u212C",
+    "bscr;": "\uD835\uDCB7",
+    "bsemi;": "\u204F",
+    "bsim;": "\u223D",
+    "bsime;": "\u22CD",
+    "bsol;": "\u005C",
+    "bsolb;": "\u29C5",
+    "bsolhsub;": "\u27C8",
+    "bull;": "\u2022",
+    "bullet;": "\u2022",
+    "bump;": "\u224E",
+    "bumpE;": "\u2AAE",
+    "bumpe;": "\u224F",
+    "Bumpeq;": "\u224E",
+    "bumpeq;": "\u224F",
+    "Cacute;": "\u0106",
+    "cacute;": "\u0107",
+    "Cap;": "\u22D2",
+    "cap;": "\u2229",
+    "capand;": "\u2A44",
+    "capbrcup;": "\u2A49",
+    "capcap;": "\u2A4B",
+    "capcup;": "\u2A47",
+    "capdot;": "\u2A40",
+    "CapitalDifferentialD;": "\u2145",
+    "caps;": "\u2229\uFE00",
+    "caret;": "\u2041",
+    "caron;": "\u02C7",
+    "Cayleys;": "\u212D",
+    "ccaps;": "\u2A4D",
+    "Ccaron;": "\u010C",
+    "ccaron;": "\u010D",
+    "Ccedil;": "\u00C7",
+    "Ccedil": "\u00C7",
+    "ccedil;": "\u00E7",
+    "ccedil": "\u00E7",
+    "Ccirc;": "\u0108",
+    "ccirc;": "\u0109",
+    "Cconint;": "\u2230",
+    "ccups;": "\u2A4C",
+    "ccupssm;": "\u2A50",
+    "Cdot;": "\u010A",
+    "cdot;": "\u010B",
+    "cedil;": "\u00B8",
+    "cedil": "\u00B8",
+    "Cedilla;": "\u00B8",
+    "cemptyv;": "\u29B2",
+    "cent;": "\u00A2",
+    "cent": "\u00A2",
+    "CenterDot;": "\u00B7",
+    "centerdot;": "\u00B7",
+    "Cfr;": "\u212D",
+    "cfr;": "\uD835\uDD20",
+    "CHcy;": "\u0427",
+    "chcy;": "\u0447",
+    "check;": "\u2713",
+    "checkmark;": "\u2713",
+    "Chi;": "\u03A7",
+    "chi;": "\u03C7",
+    "cir;": "\u25CB",
+    "circ;": "\u02C6",
+    "circeq;": "\u2257",
+    "circlearrowleft;": "\u21BA",
+    "circlearrowright;": "\u21BB",
+    "circledast;": "\u229B",
+    "circledcirc;": "\u229A",
+    "circleddash;": "\u229D",
+    "CircleDot;": "\u2299",
+    "circledR;": "\u00AE",
+    "circledS;": "\u24C8",
+    "CircleMinus;": "\u2296",
+    "CirclePlus;": "\u2295",
+    "CircleTimes;": "\u2297",
+    "cirE;": "\u29C3",
+    "cire;": "\u2257",
+    "cirfnint;": "\u2A10",
+    "cirmid;": "\u2AEF",
+    "cirscir;": "\u29C2",
+    "ClockwiseContourIntegral;": "\u2232",
+    "CloseCurlyDoubleQuote;": "\u201D",
+    "CloseCurlyQuote;": "\u2019",
+    "clubs;": "\u2663",
+    "clubsuit;": "\u2663",
+    "Colon;": "\u2237",
+    "colon;": "\u003A",
+    "Colone;": "\u2A74",
+    "colone;": "\u2254",
+    "coloneq;": "\u2254",
+    "comma;": "\u002C",
+    "commat;": "\u0040",
+    "comp;": "\u2201",
+    "compfn;": "\u2218",
+    "complement;": "\u2201",
+    "complexes;": "\u2102",
+    "cong;": "\u2245",
+    "congdot;": "\u2A6D",
+    "Congruent;": "\u2261",
+    "Conint;": "\u222F",
+    "conint;": "\u222E",
+    "ContourIntegral;": "\u222E",
+    "Copf;": "\u2102",
+    "copf;": "\uD835\uDD54",
+    "coprod;": "\u2210",
+    "Coproduct;": "\u2210",
+    "COPY;": "\u00A9",
+    "COPY": "\u00A9",
+    "copy;": "\u00A9",
+    "copy": "\u00A9",
+    "copysr;": "\u2117",
+    "CounterClockwiseContourIntegral;": "\u2233",
+    "crarr;": "\u21B5",
+    "Cross;": "\u2A2F",
+    "cross;": "\u2717",
+    "Cscr;": "\uD835\uDC9E",
+    "cscr;": "\uD835\uDCB8",
+    "csub;": "\u2ACF",
+    "csube;": "\u2AD1",
+    "csup;": "\u2AD0",
+    "csupe;": "\u2AD2",
+    "ctdot;": "\u22EF",
+    "cudarrl;": "\u2938",
+    "cudarrr;": "\u2935",
+    "cuepr;": "\u22DE",
+    "cuesc;": "\u22DF",
+    "cularr;": "\u21B6",
+    "cularrp;": "\u293D",
+    "Cup;": "\u22D3",
+    "cup;": "\u222A",
+    "cupbrcap;": "\u2A48",
+    "CupCap;": "\u224D",
+    "cupcap;": "\u2A46",
+    "cupcup;": "\u2A4A",
+    "cupdot;": "\u228D",
+    "cupor;": "\u2A45",
+    "cups;": "\u222A\uFE00",
+    "curarr;": "\u21B7",
+    "curarrm;": "\u293C",
+    "curlyeqprec;": "\u22DE",
+    "curlyeqsucc;": "\u22DF",
+    "curlyvee;": "\u22CE",
+    "curlywedge;": "\u22CF",
+    "curren;": "\u00A4",
+    "curren": "\u00A4",
+    "curvearrowleft;": "\u21B6",
+    "curvearrowright;": "\u21B7",
+    "cuvee;": "\u22CE",
+    "cuwed;": "\u22CF",
+    "cwconint;": "\u2232",
+    "cwint;": "\u2231",
+    "cylcty;": "\u232D",
+    "Dagger;": "\u2021",
+    "dagger;": "\u2020",
+    "daleth;": "\u2138",
+    "Darr;": "\u21A1",
+    "dArr;": "\u21D3",
+    "darr;": "\u2193",
+    "dash;": "\u2010",
+    "Dashv;": "\u2AE4",
+    "dashv;": "\u22A3",
+    "dbkarow;": "\u290F",
+    "dblac;": "\u02DD",
+    "Dcaron;": "\u010E",
+    "dcaron;": "\u010F",
+    "Dcy;": "\u0414",
+    "dcy;": "\u0434",
+    "DD;": "\u2145",
+    "dd;": "\u2146",
+    "ddagger;": "\u2021",
+    "ddarr;": "\u21CA",
+    "DDotrahd;": "\u2911",
+    "ddotseq;": "\u2A77",
+    "deg;": "\u00B0",
+    "deg": "\u00B0",
+    "Del;": "\u2207",
+    "Delta;": "\u0394",
+    "delta;": "\u03B4",
+    "demptyv;": "\u29B1",
+    "dfisht;": "\u297F",
+    "Dfr;": "\uD835\uDD07",
+    "dfr;": "\uD835\uDD21",
+    "dHar;": "\u2965",
+    "dharl;": "\u21C3",
+    "dharr;": "\u21C2",
+    "DiacriticalAcute;": "\u00B4",
+    "DiacriticalDot;": "\u02D9",
+    "DiacriticalDoubleAcute;": "\u02DD",
+    "DiacriticalGrave;": "\u0060",
+    "DiacriticalTilde;": "\u02DC",
+    "diam;": "\u22C4",
+    "Diamond;": "\u22C4",
+    "diamond;": "\u22C4",
+    "diamondsuit;": "\u2666",
+    "diams;": "\u2666",
+    "die;": "\u00A8",
+    "DifferentialD;": "\u2146",
+    "digamma;": "\u03DD",
+    "disin;": "\u22F2",
+    "div;": "\u00F7",
+    "divide;": "\u00F7",
+    "divide": "\u00F7",
+    "divideontimes;": "\u22C7",
+    "divonx;": "\u22C7",
+    "DJcy;": "\u0402",
+    "djcy;": "\u0452",
+    "dlcorn;": "\u231E",
+    "dlcrop;": "\u230D",
+    "dollar;": "\u0024",
+    "Dopf;": "\uD835\uDD3B",
+    "dopf;": "\uD835\uDD55",
+    "Dot;": "\u00A8",
+    "dot;": "\u02D9",
+    "DotDot;": "\u20DC",
+    "doteq;": "\u2250",
+    "doteqdot;": "\u2251",
+    "DotEqual;": "\u2250",
+    "dotminus;": "\u2238",
+    "dotplus;": "\u2214",
+    "dotsquare;": "\u22A1",
+    "doublebarwedge;": "\u2306",
+    "DoubleContourIntegral;": "\u222F",
+    "DoubleDot;": "\u00A8",
+    "DoubleDownArrow;": "\u21D3",
+    "DoubleLeftArrow;": "\u21D0",
+    "DoubleLeftRightArrow;": "\u21D4",
+    "DoubleLeftTee;": "\u2AE4",
+    "DoubleLongLeftArrow;": "\u27F8",
+    "DoubleLongLeftRightArrow;": "\u27FA",
+    "DoubleLongRightArrow;": "\u27F9",
+    "DoubleRightArrow;": "\u21D2",
+    "DoubleRightTee;": "\u22A8",
+    "DoubleUpArrow;": "\u21D1",
+    "DoubleUpDownArrow;": "\u21D5",
+    "DoubleVerticalBar;": "\u2225",
+    "DownArrow;": "\u2193",
+    "Downarrow;": "\u21D3",
+    "downarrow;": "\u2193",
+    "DownArrowBar;": "\u2913",
+    "DownArrowUpArrow;": "\u21F5",
+    "DownBreve;": "\u0311",
+    "downdownarrows;": "\u21CA",
+    "downharpoonleft;": "\u21C3",
+    "downharpoonright;": "\u21C2",
+    "DownLeftRightVector;": "\u2950",
+    "DownLeftTeeVector;": "\u295E",
+    "DownLeftVector;": "\u21BD",
+    "DownLeftVectorBar;": "\u2956",
+    "DownRightTeeVector;": "\u295F",
+    "DownRightVector;": "\u21C1",
+    "DownRightVectorBar;": "\u2957",
+    "DownTee;": "\u22A4",
+    "DownTeeArrow;": "\u21A7",
+    "drbkarow;": "\u2910",
+    "drcorn;": "\u231F",
+    "drcrop;": "\u230C",
+    "Dscr;": "\uD835\uDC9F",
+    "dscr;": "\uD835\uDCB9",
+    "DScy;": "\u0405",
+    "dscy;": "\u0455",
+    "dsol;": "\u29F6",
+    "Dstrok;": "\u0110",
+    "dstrok;": "\u0111",
+    "dtdot;": "\u22F1",
+    "dtri;": "\u25BF",
+    "dtrif;": "\u25BE",
+    "duarr;": "\u21F5",
+    "duhar;": "\u296F",
+    "dwangle;": "\u29A6",
+    "DZcy;": "\u040F",
+    "dzcy;": "\u045F",
+    "dzigrarr;": "\u27FF",
+    "Eacute;": "\u00C9",
+    "Eacute": "\u00C9",
+    "eacute;": "\u00E9",
+    "eacute": "\u00E9",
+    "easter;": "\u2A6E",
+    "Ecaron;": "\u011A",
+    "ecaron;": "\u011B",
+    "ecir;": "\u2256",
+    "Ecirc;": "\u00CA",
+    "Ecirc": "\u00CA",
+    "ecirc;": "\u00EA",
+    "ecirc": "\u00EA",
+    "ecolon;": "\u2255",
+    "Ecy;": "\u042D",
+    "ecy;": "\u044D",
+    "eDDot;": "\u2A77",
+    "Edot;": "\u0116",
+    "eDot;": "\u2251",
+    "edot;": "\u0117",
+    "ee;": "\u2147",
+    "efDot;": "\u2252",
+    "Efr;": "\uD835\uDD08",
+    "efr;": "\uD835\uDD22",
+    "eg;": "\u2A9A",
+    "Egrave;": "\u00C8",
+    "Egrave": "\u00C8",
+    "egrave;": "\u00E8",
+    "egrave": "\u00E8",
+    "egs;": "\u2A96",
+    "egsdot;": "\u2A98",
+    "el;": "\u2A99",
+    "Element;": "\u2208",
+    "elinters;": "\u23E7",
+    "ell;": "\u2113",
+    "els;": "\u2A95",
+    "elsdot;": "\u2A97",
+    "Emacr;": "\u0112",
+    "emacr;": "\u0113",
+    "empty;": "\u2205",
+    "emptyset;": "\u2205",
+    "EmptySmallSquare;": "\u25FB",
+    "emptyv;": "\u2205",
+    "EmptyVerySmallSquare;": "\u25AB",
+    "emsp;": "\u2003",
+    "emsp13;": "\u2004",
+    "emsp14;": "\u2005",
+    "ENG;": "\u014A",
+    "eng;": "\u014B",
+    "ensp;": "\u2002",
+    "Eogon;": "\u0118",
+    "eogon;": "\u0119",
+    "Eopf;": "\uD835\uDD3C",
+    "eopf;": "\uD835\uDD56",
+    "epar;": "\u22D5",
+    "eparsl;": "\u29E3",
+    "eplus;": "\u2A71",
+    "epsi;": "\u03B5",
+    "Epsilon;": "\u0395",
+    "epsilon;": "\u03B5",
+    "epsiv;": "\u03F5",
+    "eqcirc;": "\u2256",
+    "eqcolon;": "\u2255",
+    "eqsim;": "\u2242",
+    "eqslantgtr;": "\u2A96",
+    "eqslantless;": "\u2A95",
+    "Equal;": "\u2A75",
+    "equals;": "\u003D",
+    "EqualTilde;": "\u2242",
+    "equest;": "\u225F",
+    "Equilibrium;": "\u21CC",
+    "equiv;": "\u2261",
+    "equivDD;": "\u2A78",
+    "eqvparsl;": "\u29E5",
+    "erarr;": "\u2971",
+    "erDot;": "\u2253",
+    "Escr;": "\u2130",
+    "escr;": "\u212F",
+    "esdot;": "\u2250",
+    "Esim;": "\u2A73",
+    "esim;": "\u2242",
+    "Eta;": "\u0397",
+    "eta;": "\u03B7",
+    "ETH;": "\u00D0",
+    "ETH": "\u00D0",
+    "eth;": "\u00F0",
+    "eth": "\u00F0",
+    "Euml;": "\u00CB",
+    "Euml": "\u00CB",
+    "euml;": "\u00EB",
+    "euml": "\u00EB",
+    "euro;": "\u20AC",
+    "excl;": "\u0021",
+    "exist;": "\u2203",
+    "Exists;": "\u2203",
+    "expectation;": "\u2130",
+    "ExponentialE;": "\u2147",
+    "exponentiale;": "\u2147",
+    "fallingdotseq;": "\u2252",
+    "Fcy;": "\u0424",
+    "fcy;": "\u0444",
+    "female;": "\u2640",
+    "ffilig;": "\uFB03",
+    "fflig;": "\uFB00",
+    "ffllig;": "\uFB04",
+    "Ffr;": "\uD835\uDD09",
+    "ffr;": "\uD835\uDD23",
+    "filig;": "\uFB01",
+    "FilledSmallSquare;": "\u25FC",
+    "FilledVerySmallSquare;": "\u25AA",
+    "fjlig;": "\u0066\u006A",
+    "flat;": "\u266D",
+    "fllig;": "\uFB02",
+    "fltns;": "\u25B1",
+    "fnof;": "\u0192",
+    "Fopf;": "\uD835\uDD3D",
+    "fopf;": "\uD835\uDD57",
+    "ForAll;": "\u2200",
+    "forall;": "\u2200",
+    "fork;": "\u22D4",
+    "forkv;": "\u2AD9",
+    "Fouriertrf;": "\u2131",
+    "fpartint;": "\u2A0D",
+    "frac12;": "\u00BD",
+    "frac12": "\u00BD",
+    "frac13;": "\u2153",
+    "frac14;": "\u00BC",
+    "frac14": "\u00BC",
+    "frac15;": "\u2155",
+    "frac16;": "\u2159",
+    "frac18;": "\u215B",
+    "frac23;": "\u2154",
+    "frac25;": "\u2156",
+    "frac34;": "\u00BE",
+    "frac34": "\u00BE",
+    "frac35;": "\u2157",
+    "frac38;": "\u215C",
+    "frac45;": "\u2158",
+    "frac56;": "\u215A",
+    "frac58;": "\u215D",
+    "frac78;": "\u215E",
+    "frasl;": "\u2044",
+    "frown;": "\u2322",
+    "Fscr;": "\u2131",
+    "fscr;": "\uD835\uDCBB",
+    "gacute;": "\u01F5",
+    "Gamma;": "\u0393",
+    "gamma;": "\u03B3",
+    "Gammad;": "\u03DC",
+    "gammad;": "\u03DD",
+    "gap;": "\u2A86",
+    "Gbreve;": "\u011E",
+    "gbreve;": "\u011F",
+    "Gcedil;": "\u0122",
+    "Gcirc;": "\u011C",
+    "gcirc;": "\u011D",
+    "Gcy;": "\u0413",
+    "gcy;": "\u0433",
+    "Gdot;": "\u0120",
+    "gdot;": "\u0121",
+    "gE;": "\u2267",
+    "ge;": "\u2265",
+    "gEl;": "\u2A8C",
+    "gel;": "\u22DB",
+    "geq;": "\u2265",
+    "geqq;": "\u2267",
+    "geqslant;": "\u2A7E",
+    "ges;": "\u2A7E",
+    "gescc;": "\u2AA9",
+    "gesdot;": "\u2A80",
+    "gesdoto;": "\u2A82",
+    "gesdotol;": "\u2A84",
+    "gesl;": "\u22DB\uFE00",
+    "gesles;": "\u2A94",
+    "Gfr;": "\uD835\uDD0A",
+    "gfr;": "\uD835\uDD24",
+    "Gg;": "\u22D9",
+    "gg;": "\u226B",
+    "ggg;": "\u22D9",
+    "gimel;": "\u2137",
+    "GJcy;": "\u0403",
+    "gjcy;": "\u0453",
+    "gl;": "\u2277",
+    "gla;": "\u2AA5",
+    "glE;": "\u2A92",
+    "glj;": "\u2AA4",
+    "gnap;": "\u2A8A",
+    "gnapprox;": "\u2A8A",
+    "gnE;": "\u2269",
+    "gne;": "\u2A88",
+    "gneq;": "\u2A88",
+    "gneqq;": "\u2269",
+    "gnsim;": "\u22E7",
+    "Gopf;": "\uD835\uDD3E",
+    "gopf;": "\uD835\uDD58",
+    "grave;": "\u0060",
+    "GreaterEqual;": "\u2265",
+    "GreaterEqualLess;": "\u22DB",
+    "GreaterFullEqual;": "\u2267",
+    "GreaterGreater;": "\u2AA2",
+    "GreaterLess;": "\u2277",
+    "GreaterSlantEqual;": "\u2A7E",
+    "GreaterTilde;": "\u2273",
+    "Gscr;": "\uD835\uDCA2",
+    "gscr;": "\u210A",
+    "gsim;": "\u2273",
+    "gsime;": "\u2A8E",
+    "gsiml;": "\u2A90",
+    "GT;": "\u003E",
+    "GT": "\u003E",
+    "Gt;": "\u226B",
+    "gt;": "\u003E",
+    "gt": "\u003E",
+    "gtcc;": "\u2AA7",
+    "gtcir;": "\u2A7A",
+    "gtdot;": "\u22D7",
+    "gtlPar;": "\u2995",
+    "gtquest;": "\u2A7C",
+    "gtrapprox;": "\u2A86",
+    "gtrarr;": "\u2978",
+    "gtrdot;": "\u22D7",
+    "gtreqless;": "\u22DB",
+    "gtreqqless;": "\u2A8C",
+    "gtrless;": "\u2277",
+    "gtrsim;": "\u2273",
+    "gvertneqq;": "\u2269\uFE00",
+    "gvnE;": "\u2269\uFE00",
+    "Hacek;": "\u02C7",
+    "hairsp;": "\u200A",
+    "half;": "\u00BD",
+    "hamilt;": "\u210B",
+    "HARDcy;": "\u042A",
+    "hardcy;": "\u044A",
+    "hArr;": "\u21D4",
+    "harr;": "\u2194",
+    "harrcir;": "\u2948",
+    "harrw;": "\u21AD",
+    "Hat;": "\u005E",
+    "hbar;": "\u210F",
+    "Hcirc;": "\u0124",
+    "hcirc;": "\u0125",
+    "hearts;": "\u2665",
+    "heartsuit;": "\u2665",
+    "hellip;": "\u2026",
+    "hercon;": "\u22B9",
+    "Hfr;": "\u210C",
+    "hfr;": "\uD835\uDD25",
+    "HilbertSpace;": "\u210B",
+    "hksearow;": "\u2925",
+    "hkswarow;": "\u2926",
+    "hoarr;": "\u21FF",
+    "homtht;": "\u223B",
+    "hookleftarrow;": "\u21A9",
+    "hookrightarrow;": "\u21AA",
+    "Hopf;": "\u210D",
+    "hopf;": "\uD835\uDD59",
+    "horbar;": "\u2015",
+    "HorizontalLine;": "\u2500",
+    "Hscr;": "\u210B",
+    "hscr;": "\uD835\uDCBD",
+    "hslash;": "\u210F",
+    "Hstrok;": "\u0126",
+    "hstrok;": "\u0127",
+    "HumpDownHump;": "\u224E",
+    "HumpEqual;": "\u224F",
+    "hybull;": "\u2043",
+    "hyphen;": "\u2010",
+    "Iacute;": "\u00CD",
+    "Iacute": "\u00CD",
+    "iacute;": "\u00ED",
+    "iacute": "\u00ED",
+    "ic;": "\u2063",
+    "Icirc;": "\u00CE",
+    "Icirc": "\u00CE",
+    "icirc;": "\u00EE",
+    "icirc": "\u00EE",
+    "Icy;": "\u0418",
+    "icy;": "\u0438",
+    "Idot;": "\u0130",
+    "IEcy;": "\u0415",
+    "iecy;": "\u0435",
+    "iexcl;": "\u00A1",
+    "iexcl": "\u00A1",
+    "iff;": "\u21D4",
+    "Ifr;": "\u2111",
+    "ifr;": "\uD835\uDD26",
+    "Igrave;": "\u00CC",
+    "Igrave": "\u00CC",
+    "igrave;": "\u00EC",
+    "igrave": "\u00EC",
+    "ii;": "\u2148",
+    "iiiint;": "\u2A0C",
+    "iiint;": "\u222D",
+    "iinfin;": "\u29DC",
+    "iiota;": "\u2129",
+    "IJlig;": "\u0132",
+    "ijlig;": "\u0133",
+    "Im;": "\u2111",
+    "Imacr;": "\u012A",
+    "imacr;": "\u012B",
+    "image;": "\u2111",
+    "ImaginaryI;": "\u2148",
+    "imagline;": "\u2110",
+    "imagpart;": "\u2111",
+    "imath;": "\u0131",
+    "imof;": "\u22B7",
+    "imped;": "\u01B5",
+    "Implies;": "\u21D2",
+    "in;": "\u2208",
+    "incare;": "\u2105",
+    "infin;": "\u221E",
+    "infintie;": "\u29DD",
+    "inodot;": "\u0131",
+    "Int;": "\u222C",
+    "int;": "\u222B",
+    "intcal;": "\u22BA",
+    "integers;": "\u2124",
+    "Integral;": "\u222B",
+    "intercal;": "\u22BA",
+    "Intersection;": "\u22C2",
+    "intlarhk;": "\u2A17",
+    "intprod;": "\u2A3C",
+    "InvisibleComma;": "\u2063",
+    "InvisibleTimes;": "\u2062",
+    "IOcy;": "\u0401",
+    "iocy;": "\u0451",
+    "Iogon;": "\u012E",
+    "iogon;": "\u012F",
+    "Iopf;": "\uD835\uDD40",
+    "iopf;": "\uD835\uDD5A",
+    "Iota;": "\u0399",
+    "iota;": "\u03B9",
+    "iprod;": "\u2A3C",
+    "iquest;": "\u00BF",
+    "iquest": "\u00BF",
+    "Iscr;": "\u2110",
+    "iscr;": "\uD835\uDCBE",
+    "isin;": "\u2208",
+    "isindot;": "\u22F5",
+    "isinE;": "\u22F9",
+    "isins;": "\u22F4",
+    "isinsv;": "\u22F3",
+    "isinv;": "\u2208",
+    "it;": "\u2062",
+    "Itilde;": "\u0128",
+    "itilde;": "\u0129",
+    "Iukcy;": "\u0406",
+    "iukcy;": "\u0456",
+    "Iuml;": "\u00CF",
+    "Iuml": "\u00CF",
+    "iuml;": "\u00EF",
+    "iuml": "\u00EF",
+    "Jcirc;": "\u0134",
+    "jcirc;": "\u0135",
+    "Jcy;": "\u0419",
+    "jcy;": "\u0439",
+    "Jfr;": "\uD835\uDD0D",
+    "jfr;": "\uD835\uDD27",
+    "jmath;": "\u0237",
+    "Jopf;": "\uD835\uDD41",
+    "jopf;": "\uD835\uDD5B",
+    "Jscr;": "\uD835\uDCA5",
+    "jscr;": "\uD835\uDCBF",
+    "Jsercy;": "\u0408",
+    "jsercy;": "\u0458",
+    "Jukcy;": "\u0404",
+    "jukcy;": "\u0454",
+    "Kappa;": "\u039A",
+    "kappa;": "\u03BA",
+    "kappav;": "\u03F0",
+    "Kcedil;": "\u0136",
+    "kcedil;": "\u0137",
+    "Kcy;": "\u041A",
+    "kcy;": "\u043A",
+    "Kfr;": "\uD835\uDD0E",
+    "kfr;": "\uD835\uDD28",
+    "kgreen;": "\u0138",
+    "KHcy;": "\u0425",
+    "khcy;": "\u0445",
+    "KJcy;": "\u040C",
+    "kjcy;": "\u045C",
+    "Kopf;": "\uD835\uDD42",
+    "kopf;": "\uD835\uDD5C",
+    "Kscr;": "\uD835\uDCA6",
+    "kscr;": "\uD835\uDCC0",
+    "lAarr;": "\u21DA",
+    "Lacute;": "\u0139",
+    "lacute;": "\u013A",
+    "laemptyv;": "\u29B4",
+    "lagran;": "\u2112",
+    "Lambda;": "\u039B",
+    "lambda;": "\u03BB",
+    "Lang;": "\u27EA",
+    "lang;": "\u27E8",
+    "langd;": "\u2991",
+    "langle;": "\u27E8",
+    "lap;": "\u2A85",
+    "Laplacetrf;": "\u2112",
+    "laquo;": "\u00AB",
+    "laquo": "\u00AB",
+    "Larr;": "\u219E",
+    "lArr;": "\u21D0",
+    "larr;": "\u2190",
+    "larrb;": "\u21E4",
+    "larrbfs;": "\u291F",
+    "larrfs;": "\u291D",
+    "larrhk;": "\u21A9",
+    "larrlp;": "\u21AB",
+    "larrpl;": "\u2939",
+    "larrsim;": "\u2973",
+    "larrtl;": "\u21A2",
+    "lat;": "\u2AAB",
+    "lAtail;": "\u291B",
+    "latail;": "\u2919",
+    "late;": "\u2AAD",
+    "lates;": "\u2AAD\uFE00",
+    "lBarr;": "\u290E",
+    "lbarr;": "\u290C",
+    "lbbrk;": "\u2772",
+    "lbrace;": "\u007B",
+    "lbrack;": "\u005B",
+    "lbrke;": "\u298B",
+    "lbrksld;": "\u298F",
+    "lbrkslu;": "\u298D",
+    "Lcaron;": "\u013D",
+    "lcaron;": "\u013E",
+    "Lcedil;": "\u013B",
+    "lcedil;": "\u013C",
+    "lceil;": "\u2308",
+    "lcub;": "\u007B",
+    "Lcy;": "\u041B",
+    "lcy;": "\u043B",
+    "ldca;": "\u2936",
+    "ldquo;": "\u201C",
+    "ldquor;": "\u201E",
+    "ldrdhar;": "\u2967",
+    "ldrushar;": "\u294B",
+    "ldsh;": "\u21B2",
+    "lE;": "\u2266",
+    "le;": "\u2264",
+    "LeftAngleBracket;": "\u27E8",
+    "LeftArrow;": "\u2190",
+    "Leftarrow;": "\u21D0",
+    "leftarrow;": "\u2190",
+    "LeftArrowBar;": "\u21E4",
+    "LeftArrowRightArrow;": "\u21C6",
+    "leftarrowtail;": "\u21A2",
+    "LeftCeiling;": "\u2308",
+    "LeftDoubleBracket;": "\u27E6",
+    "LeftDownTeeVector;": "\u2961",
+    "LeftDownVector;": "\u21C3",
+    "LeftDownVectorBar;": "\u2959",
+    "LeftFloor;": "\u230A",
+    "leftharpoondown;": "\u21BD",
+    "leftharpoonup;": "\u21BC",
+    "leftleftarrows;": "\u21C7",
+    "LeftRightArrow;": "\u2194",
+    "Leftrightarrow;": "\u21D4",
+    "leftrightarrow;": "\u2194",
+    "leftrightarrows;": "\u21C6",
+    "leftrightharpoons;": "\u21CB",
+    "leftrightsquigarrow;": "\u21AD",
+    "LeftRightVector;": "\u294E",
+    "LeftTee;": "\u22A3",
+    "LeftTeeArrow;": "\u21A4",
+    "LeftTeeVector;": "\u295A",
+    "leftthreetimes;": "\u22CB",
+    "LeftTriangle;": "\u22B2",
+    "LeftTriangleBar;": "\u29CF",
+    "LeftTriangleEqual;": "\u22B4",
+    "LeftUpDownVector;": "\u2951",
+    "LeftUpTeeVector;": "\u2960",
+    "LeftUpVector;": "\u21BF",
+    "LeftUpVectorBar;": "\u2958",
+    "LeftVector;": "\u21BC",
+    "LeftVectorBar;": "\u2952",
+    "lEg;": "\u2A8B",
+    "leg;": "\u22DA",
+    "leq;": "\u2264",
+    "leqq;": "\u2266",
+    "leqslant;": "\u2A7D",
+    "les;": "\u2A7D",
+    "lescc;": "\u2AA8",
+    "lesdot;": "\u2A7F",
+    "lesdoto;": "\u2A81",
+    "lesdotor;": "\u2A83",
+    "lesg;": "\u22DA\uFE00",
+    "lesges;": "\u2A93",
+    "lessapprox;": "\u2A85",
+    "lessdot;": "\u22D6",
+    "lesseqgtr;": "\u22DA",
+    "lesseqqgtr;": "\u2A8B",
+    "LessEqualGreater;": "\u22DA",
+    "LessFullEqual;": "\u2266",
+    "LessGreater;": "\u2276",
+    "lessgtr;": "\u2276",
+    "LessLess;": "\u2AA1",
+    "lesssim;": "\u2272",
+    "LessSlantEqual;": "\u2A7D",
+    "LessTilde;": "\u2272",
+    "lfisht;": "\u297C",
+    "lfloor;": "\u230A",
+    "Lfr;": "\uD835\uDD0F",
+    "lfr;": "\uD835\uDD29",
+    "lg;": "\u2276",
+    "lgE;": "\u2A91",
+    "lHar;": "\u2962",
+    "lhard;": "\u21BD",
+    "lharu;": "\u21BC",
+    "lharul;": "\u296A",
+    "lhblk;": "\u2584",
+    "LJcy;": "\u0409",
+    "ljcy;": "\u0459",
+    "Ll;": "\u22D8",
+    "ll;": "\u226A",
+    "llarr;": "\u21C7",
+    "llcorner;": "\u231E",
+    "Lleftarrow;": "\u21DA",
+    "llhard;": "\u296B",
+    "lltri;": "\u25FA",
+    "Lmidot;": "\u013F",
+    "lmidot;": "\u0140",
+    "lmoust;": "\u23B0",
+    "lmoustache;": "\u23B0",
+    "lnap;": "\u2A89",
+    "lnapprox;": "\u2A89",
+    "lnE;": "\u2268",
+    "lne;": "\u2A87",
+    "lneq;": "\u2A87",
+    "lneqq;": "\u2268",
+    "lnsim;": "\u22E6",
+    "loang;": "\u27EC",
+    "loarr;": "\u21FD",
+    "lobrk;": "\u27E6",
+    "LongLeftArrow;": "\u27F5",
+    "Longleftarrow;": "\u27F8",
+    "longleftarrow;": "\u27F5",
+    "LongLeftRightArrow;": "\u27F7",
+    "Longleftrightarrow;": "\u27FA",
+    "longleftrightarrow;": "\u27F7",
+    "longmapsto;": "\u27FC",
+    "LongRightArrow;": "\u27F6",
+    "Longrightarrow;": "\u27F9",
+    "longrightarrow;": "\u27F6",
+    "looparrowleft;": "\u21AB",
+    "looparrowright;": "\u21AC",
+    "lopar;": "\u2985",
+    "Lopf;": "\uD835\uDD43",
+    "lopf;": "\uD835\uDD5D",
+    "loplus;": "\u2A2D",
+    "lotimes;": "\u2A34",
+    "lowast;": "\u2217",
+    "lowbar;": "\u005F",
+    "LowerLeftArrow;": "\u2199",
+    "LowerRightArrow;": "\u2198",
+    "loz;": "\u25CA",
+    "lozenge;": "\u25CA",
+    "lozf;": "\u29EB",
+    "lpar;": "\u0028",
+    "lparlt;": "\u2993",
+    "lrarr;": "\u21C6",
+    "lrcorner;": "\u231F",
+    "lrhar;": "\u21CB",
+    "lrhard;": "\u296D",
+    "lrm;": "\u200E",
+    "lrtri;": "\u22BF",
+    "lsaquo;": "\u2039",
+    "Lscr;": "\u2112",
+    "lscr;": "\uD835\uDCC1",
+    "Lsh;": "\u21B0",
+    "lsh;": "\u21B0",
+    "lsim;": "\u2272",
+    "lsime;": "\u2A8D",
+    "lsimg;": "\u2A8F",
+    "lsqb;": "\u005B",
+    "lsquo;": "\u2018",
+    "lsquor;": "\u201A",
+    "Lstrok;": "\u0141",
+    "lstrok;": "\u0142",
+    "LT;": "\u003C",
+    "LT": "\u003C",
+    "Lt;": "\u226A",
+    "lt;": "\u003C",
+    "lt": "\u003C",
+    "ltcc;": "\u2AA6",
+    "ltcir;": "\u2A79",
+    "ltdot;": "\u22D6",
+    "lthree;": "\u22CB",
+    "ltimes;": "\u22C9",
+    "ltlarr;": "\u2976",
+    "ltquest;": "\u2A7B",
+    "ltri;": "\u25C3",
+    "ltrie;": "\u22B4",
+    "ltrif;": "\u25C2",
+    "ltrPar;": "\u2996",
+    "lurdshar;": "\u294A",
+    "luruhar;": "\u2966",
+    "lvertneqq;": "\u2268\uFE00",
+    "lvnE;": "\u2268\uFE00",
+    "macr;": "\u00AF",
+    "macr": "\u00AF",
+    "male;": "\u2642",
+    "malt;": "\u2720",
+    "maltese;": "\u2720",
+    "Map;": "\u2905",
+    "map;": "\u21A6",
+    "mapsto;": "\u21A6",
+    "mapstodown;": "\u21A7",
+    "mapstoleft;": "\u21A4",
+    "mapstoup;": "\u21A5",
+    "marker;": "\u25AE",
+    "mcomma;": "\u2A29",
+    "Mcy;": "\u041C",
+    "mcy;": "\u043C",
+    "mdash;": "\u2014",
+    "mDDot;": "\u223A",
+    "measuredangle;": "\u2221",
+    "MediumSpace;": "\u205F",
+    "Mellintrf;": "\u2133",
+    "Mfr;": "\uD835\uDD10",
+    "mfr;": "\uD835\uDD2A",
+    "mho;": "\u2127",
+    "micro;": "\u00B5",
+    "micro": "\u00B5",
+    "mid;": "\u2223",
+    "midast;": "\u002A",
+    "midcir;": "\u2AF0",
+    "middot;": "\u00B7",
+    "middot": "\u00B7",
+    "minus;": "\u2212",
+    "minusb;": "\u229F",
+    "minusd;": "\u2238",
+    "minusdu;": "\u2A2A",
+    "MinusPlus;": "\u2213",
+    "mlcp;": "\u2ADB",
+    "mldr;": "\u2026",
+    "mnplus;": "\u2213",
+    "models;": "\u22A7",
+    "Mopf;": "\uD835\uDD44",
+    "mopf;": "\uD835\uDD5E",
+    "mp;": "\u2213",
+    "Mscr;": "\u2133",
+    "mscr;": "\uD835\uDCC2",
+    "mstpos;": "\u223E",
+    "Mu;": "\u039C",
+    "mu;": "\u03BC",
+    "multimap;": "\u22B8",
+    "mumap;": "\u22B8",
+    "nabla;": "\u2207",
+    "Nacute;": "\u0143",
+    "nacute;": "\u0144",
+    "nang;": "\u2220\u20D2",
+    "nap;": "\u2249",
+    "napE;": "\u2A70\u0338",
+    "napid;": "\u224B\u0338",
+    "napos;": "\u0149",
+    "napprox;": "\u2249",
+    "natur;": "\u266E",
+    "natural;": "\u266E",
+    "naturals;": "\u2115",
+    "nbsp;": "\u00A0",
+    "nbsp": "\u00A0",
+    "nbump;": "\u224E\u0338",
+    "nbumpe;": "\u224F\u0338",
+    "ncap;": "\u2A43",
+    "Ncaron;": "\u0147",
+    "ncaron;": "\u0148",
+    "Ncedil;": "\u0145",
+    "ncedil;": "\u0146",
+    "ncong;": "\u2247",
+    "ncongdot;": "\u2A6D\u0338",
+    "ncup;": "\u2A42",
+    "Ncy;": "\u041D",
+    "ncy;": "\u043D",
+    "ndash;": "\u2013",
+    "ne;": "\u2260",
+    "nearhk;": "\u2924",
+    "neArr;": "\u21D7",
+    "nearr;": "\u2197",
+    "nearrow;": "\u2197",
+    "nedot;": "\u2250\u0338",
+    "NegativeMediumSpace;": "\u200B",
+    "NegativeThickSpace;": "\u200B",
+    "NegativeThinSpace;": "\u200B",
+    "NegativeVeryThinSpace;": "\u200B",
+    "nequiv;": "\u2262",
+    "nesear;": "\u2928",
+    "nesim;": "\u2242\u0338",
+    "NestedGreaterGreater;": "\u226B",
+    "NestedLessLess;": "\u226A",
+    "NewLine;": "\u000A",
+    "nexist;": "\u2204",
+    "nexists;": "\u2204",
+    "Nfr;": "\uD835\uDD11",
+    "nfr;": "\uD835\uDD2B",
+    "ngE;": "\u2267\u0338",
+    "nge;": "\u2271",
+    "ngeq;": "\u2271",
+    "ngeqq;": "\u2267\u0338",
+    "ngeqslant;": "\u2A7E\u0338",
+    "nges;": "\u2A7E\u0338",
+    "nGg;": "\u22D9\u0338",
+    "ngsim;": "\u2275",
+    "nGt;": "\u226B\u20D2",
+    "ngt;": "\u226F",
+    "ngtr;": "\u226F",
+    "nGtv;": "\u226B\u0338",
+    "nhArr;": "\u21CE",
+    "nharr;": "\u21AE",
+    "nhpar;": "\u2AF2",
+    "ni;": "\u220B",
+    "nis;": "\u22FC",
+    "nisd;": "\u22FA",
+    "niv;": "\u220B",
+    "NJcy;": "\u040A",
+    "njcy;": "\u045A",
+    "nlArr;": "\u21CD",
+    "nlarr;": "\u219A",
+    "nldr;": "\u2025",
+    "nlE;": "\u2266\u0338",
+    "nle;": "\u2270",
+    "nLeftarrow;": "\u21CD",
+    "nleftarrow;": "\u219A",
+    "nLeftrightarrow;": "\u21CE",
+    "nleftrightarrow;": "\u21AE",
+    "nleq;": "\u2270",
+    "nleqq;": "\u2266\u0338",
+    "nleqslant;": "\u2A7D\u0338",
+    "nles;": "\u2A7D\u0338",
+    "nless;": "\u226E",
+    "nLl;": "\u22D8\u0338",
+    "nlsim;": "\u2274",
+    "nLt;": "\u226A\u20D2",
+    "nlt;": "\u226E",
+    "nltri;": "\u22EA",
+    "nltrie;": "\u22EC",
+    "nLtv;": "\u226A\u0338",
+    "nmid;": "\u2224",
+    "NoBreak;": "\u2060",
+    "NonBreakingSpace;": "\u00A0",
+    "Nopf;": "\u2115",
+    "nopf;": "\uD835\uDD5F",
+    "Not;": "\u2AEC",
+    "not;": "\u00AC",
+    "not": "\u00AC",
+    "NotCongruent;": "\u2262",
+    "NotCupCap;": "\u226D",
+    "NotDoubleVerticalBar;": "\u2226",
+    "NotElement;": "\u2209",
+    "NotEqual;": "\u2260",
+    "NotEqualTilde;": "\u2242\u0338",
+    "NotExists;": "\u2204",
+    "NotGreater;": "\u226F",
+    "NotGreaterEqual;": "\u2271",
+    "NotGreaterFullEqual;": "\u2267\u0338",
+    "NotGreaterGreater;": "\u226B\u0338",
+    "NotGreaterLess;": "\u2279",
+    "NotGreaterSlantEqual;": "\u2A7E\u0338",
+    "NotGreaterTilde;": "\u2275",
+    "NotHumpDownHump;": "\u224E\u0338",
+    "NotHumpEqual;": "\u224F\u0338",
+    "notin;": "\u2209",
+    "notindot;": "\u22F5\u0338",
+    "notinE;": "\u22F9\u0338",
+    "notinva;": "\u2209",
+    "notinvb;": "\u22F7",
+    "notinvc;": "\u22F6",
+    "NotLeftTriangle;": "\u22EA",
+    "NotLeftTriangleBar;": "\u29CF\u0338",
+    "NotLeftTriangleEqual;": "\u22EC",
+    "NotLess;": "\u226E",
+    "NotLessEqual;": "\u2270",
+    "NotLessGreater;": "\u2278",
+    "NotLessLess;": "\u226A\u0338",
+    "NotLessSlantEqual;": "\u2A7D\u0338",
+    "NotLessTilde;": "\u2274",
+    "NotNestedGreaterGreater;": "\u2AA2\u0338",
+    "NotNestedLessLess;": "\u2AA1\u0338",
+    "notni;": "\u220C",
+    "notniva;": "\u220C",
+    "notnivb;": "\u22FE",
+    "notnivc;": "\u22FD",
+    "NotPrecedes;": "\u2280",
+    "NotPrecedesEqual;": "\u2AAF\u0338",
+    "NotPrecedesSlantEqual;": "\u22E0",
+    "NotReverseElement;": "\u220C",
+    "NotRightTriangle;": "\u22EB",
+    "NotRightTriangleBar;": "\u29D0\u0338",
+    "NotRightTriangleEqual;": "\u22ED",
+    "NotSquareSubset;": "\u228F\u0338",
+    "NotSquareSubsetEqual;": "\u22E2",
+    "NotSquareSuperset;": "\u2290\u0338",
+    "NotSquareSupersetEqual;": "\u22E3",
+    "NotSubset;": "\u2282\u20D2",
+    "NotSubsetEqual;": "\u2288",
+    "NotSucceeds;": "\u2281",
+    "NotSucceedsEqual;": "\u2AB0\u0338",
+    "NotSucceedsSlantEqual;": "\u22E1",
+    "NotSucceedsTilde;": "\u227F\u0338",
+    "NotSuperset;": "\u2283\u20D2",
+    "NotSupersetEqual;": "\u2289",
+    "NotTilde;": "\u2241",
+    "NotTildeEqual;": "\u2244",
+    "NotTildeFullEqual;": "\u2247",
+    "NotTildeTilde;": "\u2249",
+    "NotVerticalBar;": "\u2224",
+    "npar;": "\u2226",
+    "nparallel;": "\u2226",
+    "nparsl;": "\u2AFD\u20E5",
+    "npart;": "\u2202\u0338",
+    "npolint;": "\u2A14",
+    "npr;": "\u2280",
+    "nprcue;": "\u22E0",
+    "npre;": "\u2AAF\u0338",
+    "nprec;": "\u2280",
+    "npreceq;": "\u2AAF\u0338",
+    "nrArr;": "\u21CF",
+    "nrarr;": "\u219B",
+    "nrarrc;": "\u2933\u0338",
+    "nrarrw;": "\u219D\u0338",
+    "nRightarrow;": "\u21CF",
+    "nrightarrow;": "\u219B",
+    "nrtri;": "\u22EB",
+    "nrtrie;": "\u22ED",
+    "nsc;": "\u2281",
+    "nsccue;": "\u22E1",
+    "nsce;": "\u2AB0\u0338",
+    "Nscr;": "\uD835\uDCA9",
+    "nscr;": "\uD835\uDCC3",
+    "nshortmid;": "\u2224",
+    "nshortparallel;": "\u2226",
+    "nsim;": "\u2241",
+    "nsime;": "\u2244",
+    "nsimeq;": "\u2244",
+    "nsmid;": "\u2224",
+    "nspar;": "\u2226",
+    "nsqsube;": "\u22E2",
+    "nsqsupe;": "\u22E3",
+    "nsub;": "\u2284",
+    "nsubE;": "\u2AC5\u0338",
+    "nsube;": "\u2288",
+    "nsubset;": "\u2282\u20D2",
+    "nsubseteq;": "\u2288",
+    "nsubseteqq;": "\u2AC5\u0338",
+    "nsucc;": "\u2281",
+    "nsucceq;": "\u2AB0\u0338",
+    "nsup;": "\u2285",
+    "nsupE;": "\u2AC6\u0338",
+    "nsupe;": "\u2289",
+    "nsupset;": "\u2283\u20D2",
+    "nsupseteq;": "\u2289",
+    "nsupseteqq;": "\u2AC6\u0338",
+    "ntgl;": "\u2279",
+    "Ntilde;": "\u00D1",
+    "Ntilde": "\u00D1",
+    "ntilde;": "\u00F1",
+    "ntilde": "\u00F1",
+    "ntlg;": "\u2278",
+    "ntriangleleft;": "\u22EA",
+    "ntrianglelefteq;": "\u22EC",
+    "ntriangleright;": "\u22EB",
+    "ntrianglerighteq;": "\u22ED",
+    "Nu;": "\u039D",
+    "nu;": "\u03BD",
+    "num;": "\u0023",
+    "numero;": "\u2116",
+    "numsp;": "\u2007",
+    "nvap;": "\u224D\u20D2",
+    "nVDash;": "\u22AF",
+    "nVdash;": "\u22AE",
+    "nvDash;": "\u22AD",
+    "nvdash;": "\u22AC",
+    "nvge;": "\u2265\u20D2",
+    "nvgt;": "\u003E\u20D2",
+    "nvHarr;": "\u2904",
+    "nvinfin;": "\u29DE",
+    "nvlArr;": "\u2902",
+    "nvle;": "\u2264\u20D2",
+    "nvlt;": "\u003C\u20D2",
+    "nvltrie;": "\u22B4\u20D2",
+    "nvrArr;": "\u2903",
+    "nvrtrie;": "\u22B5\u20D2",
+    "nvsim;": "\u223C\u20D2",
+    "nwarhk;": "\u2923",
+    "nwArr;": "\u21D6",
+    "nwarr;": "\u2196",
+    "nwarrow;": "\u2196",
+    "nwnear;": "\u2927",
+    "Oacute;": "\u00D3",
+    "Oacute": "\u00D3",
+    "oacute;": "\u00F3",
+    "oacute": "\u00F3",
+    "oast;": "\u229B",
+    "ocir;": "\u229A",
+    "Ocirc;": "\u00D4",
+    "Ocirc": "\u00D4",
+    "ocirc;": "\u00F4",
+    "ocirc": "\u00F4",
+    "Ocy;": "\u041E",
+    "ocy;": "\u043E",
+    "odash;": "\u229D",
+    "Odblac;": "\u0150",
+    "odblac;": "\u0151",
+    "odiv;": "\u2A38",
+    "odot;": "\u2299",
+    "odsold;": "\u29BC",
+    "OElig;": "\u0152",
+    "oelig;": "\u0153",
+    "ofcir;": "\u29BF",
+    "Ofr;": "\uD835\uDD12",
+    "ofr;": "\uD835\uDD2C",
+    "ogon;": "\u02DB",
+    "Ograve;": "\u00D2",
+    "Ograve": "\u00D2",
+    "ograve;": "\u00F2",
+    "ograve": "\u00F2",
+    "ogt;": "\u29C1",
+    "ohbar;": "\u29B5",
+    "ohm;": "\u03A9",
+    "oint;": "\u222E",
+    "olarr;": "\u21BA",
+    "olcir;": "\u29BE",
+    "olcross;": "\u29BB",
+    "oline;": "\u203E",
+    "olt;": "\u29C0",
+    "Omacr;": "\u014C",
+    "omacr;": "\u014D",
+    "Omega;": "\u03A9",
+    "omega;": "\u03C9",
+    "Omicron;": "\u039F",
+    "omicron;": "\u03BF",
+    "omid;": "\u29B6",
+    "ominus;": "\u2296",
+    "Oopf;": "\uD835\uDD46",
+    "oopf;": "\uD835\uDD60",
+    "opar;": "\u29B7",
+    "OpenCurlyDoubleQuote;": "\u201C",
+    "OpenCurlyQuote;": "\u2018",
+    "operp;": "\u29B9",
+    "oplus;": "\u2295",
+    "Or;": "\u2A54",
+    "or;": "\u2228",
+    "orarr;": "\u21BB",
+    "ord;": "\u2A5D",
+    "order;": "\u2134",
+    "orderof;": "\u2134",
+    "ordf;": "\u00AA",
+    "ordf": "\u00AA",
+    "ordm;": "\u00BA",
+    "ordm": "\u00BA",
+    "origof;": "\u22B6",
+    "oror;": "\u2A56",
+    "orslope;": "\u2A57",
+    "orv;": "\u2A5B",
+    "oS;": "\u24C8",
+    "Oscr;": "\uD835\uDCAA",
+    "oscr;": "\u2134",
+    "Oslash;": "\u00D8",
+    "Oslash": "\u00D8",
+    "oslash;": "\u00F8",
+    "oslash": "\u00F8",
+    "osol;": "\u2298",
+    "Otilde;": "\u00D5",
+    "Otilde": "\u00D5",
+    "otilde;": "\u00F5",
+    "otilde": "\u00F5",
+    "Otimes;": "\u2A37",
+    "otimes;": "\u2297",
+    "otimesas;": "\u2A36",
+    "Ouml;": "\u00D6",
+    "Ouml": "\u00D6",
+    "ouml;": "\u00F6",
+    "ouml": "\u00F6",
+    "ovbar;": "\u233D",
+    "OverBar;": "\u203E",
+    "OverBrace;": "\u23DE",
+    "OverBracket;": "\u23B4",
+    "OverParenthesis;": "\u23DC",
+    "par;": "\u2225",
+    "para;": "\u00B6",
+    "para": "\u00B6",
+    "parallel;": "\u2225",
+    "parsim;": "\u2AF3",
+    "parsl;": "\u2AFD",
+    "part;": "\u2202",
+    "PartialD;": "\u2202",
+    "Pcy;": "\u041F",
+    "pcy;": "\u043F",
+    "percnt;": "\u0025",
+    "period;": "\u002E",
+    "permil;": "\u2030",
+    "perp;": "\u22A5",
+    "pertenk;": "\u2031",
+    "Pfr;": "\uD835\uDD13",
+    "pfr;": "\uD835\uDD2D",
+    "Phi;": "\u03A6",
+    "phi;": "\u03C6",
+    "phiv;": "\u03D5",
+    "phmmat;": "\u2133",
+    "phone;": "\u260E",
+    "Pi;": "\u03A0",
+    "pi;": "\u03C0",
+    "pitchfork;": "\u22D4",
+    "piv;": "\u03D6",
+    "planck;": "\u210F",
+    "planckh;": "\u210E",
+    "plankv;": "\u210F",
+    "plus;": "\u002B",
+    "plusacir;": "\u2A23",
+    "plusb;": "\u229E",
+    "pluscir;": "\u2A22",
+    "plusdo;": "\u2214",
+    "plusdu;": "\u2A25",
+    "pluse;": "\u2A72",
+    "PlusMinus;": "\u00B1",
+    "plusmn;": "\u00B1",
+    "plusmn": "\u00B1",
+    "plussim;": "\u2A26",
+    "plustwo;": "\u2A27",
+    "pm;": "\u00B1",
+    "Poincareplane;": "\u210C",
+    "pointint;": "\u2A15",
+    "Popf;": "\u2119",
+    "popf;": "\uD835\uDD61",
+    "pound;": "\u00A3",
+    "pound": "\u00A3",
+    "Pr;": "\u2ABB",
+    "pr;": "\u227A",
+    "prap;": "\u2AB7",
+    "prcue;": "\u227C",
+    "prE;": "\u2AB3",
+    "pre;": "\u2AAF",
+    "prec;": "\u227A",
+    "precapprox;": "\u2AB7",
+    "preccurlyeq;": "\u227C",
+    "Precedes;": "\u227A",
+    "PrecedesEqual;": "\u2AAF",
+    "PrecedesSlantEqual;": "\u227C",
+    "PrecedesTilde;": "\u227E",
+    "preceq;": "\u2AAF",
+    "precnapprox;": "\u2AB9",
+    "precneqq;": "\u2AB5",
+    "precnsim;": "\u22E8",
+    "precsim;": "\u227E",
+    "Prime;": "\u2033",
+    "prime;": "\u2032",
+    "primes;": "\u2119",
+    "prnap;": "\u2AB9",
+    "prnE;": "\u2AB5",
+    "prnsim;": "\u22E8",
+    "prod;": "\u220F",
+    "Product;": "\u220F",
+    "profalar;": "\u232E",
+    "profline;": "\u2312",
+    "profsurf;": "\u2313",
+    "prop;": "\u221D",
+    "Proportion;": "\u2237",
+    "Proportional;": "\u221D",
+    "propto;": "\u221D",
+    "prsim;": "\u227E",
+    "prurel;": "\u22B0",
+    "Pscr;": "\uD835\uDCAB",
+    "pscr;": "\uD835\uDCC5",
+    "Psi;": "\u03A8",
+    "psi;": "\u03C8",
+    "puncsp;": "\u2008",
+    "Qfr;": "\uD835\uDD14",
+    "qfr;": "\uD835\uDD2E",
+    "qint;": "\u2A0C",
+    "Qopf;": "\u211A",
+    "qopf;": "\uD835\uDD62",
+    "qprime;": "\u2057",
+    "Qscr;": "\uD835\uDCAC",
+    "qscr;": "\uD835\uDCC6",
+    "quaternions;": "\u210D",
+    "quatint;": "\u2A16",
+    "quest;": "\u003F",
+    "questeq;": "\u225F",
+    "QUOT;": "\u0022",
+    "QUOT": "\u0022",
+    "quot;": "\u0022",
+    "quot": "\u0022",
+    "rAarr;": "\u21DB",
+    "race;": "\u223D\u0331",
+    "Racute;": "\u0154",
+    "racute;": "\u0155",
+    "radic;": "\u221A",
+    "raemptyv;": "\u29B3",
+    "Rang;": "\u27EB",
+    "rang;": "\u27E9",
+    "rangd;": "\u2992",
+    "range;": "\u29A5",
+    "rangle;": "\u27E9",
+    "raquo;": "\u00BB",
+    "raquo": "\u00BB",
+    "Rarr;": "\u21A0",
+    "rArr;": "\u21D2",
+    "rarr;": "\u2192",
+    "rarrap;": "\u2975",
+    "rarrb;": "\u21E5",
+    "rarrbfs;": "\u2920",
+    "rarrc;": "\u2933",
+    "rarrfs;": "\u291E",
+    "rarrhk;": "\u21AA",
+    "rarrlp;": "\u21AC",
+    "rarrpl;": "\u2945",
+    "rarrsim;": "\u2974",
+    "Rarrtl;": "\u2916",
+    "rarrtl;": "\u21A3",
+    "rarrw;": "\u219D",
+    "rAtail;": "\u291C",
+    "ratail;": "\u291A",
+    "ratio;": "\u2236",
+    "rationals;": "\u211A",
+    "RBarr;": "\u2910",
+    "rBarr;": "\u290F",
+    "rbarr;": "\u290D",
+    "rbbrk;": "\u2773",
+    "rbrace;": "\u007D",
+    "rbrack;": "\u005D",
+    "rbrke;": "\u298C",
+    "rbrksld;": "\u298E",
+    "rbrkslu;": "\u2990",
+    "Rcaron;": "\u0158",
+    "rcaron;": "\u0159",
+    "Rcedil;": "\u0156",
+    "rcedil;": "\u0157",
+    "rceil;": "\u2309",
+    "rcub;": "\u007D",
+    "Rcy;": "\u0420",
+    "rcy;": "\u0440",
+    "rdca;": "\u2937",
+    "rdldhar;": "\u2969",
+    "rdquo;": "\u201D",
+    "rdquor;": "\u201D",
+    "rdsh;": "\u21B3",
+    "Re;": "\u211C",
+    "real;": "\u211C",
+    "realine;": "\u211B",
+    "realpart;": "\u211C",
+    "reals;": "\u211D",
+    "rect;": "\u25AD",
+    "REG;": "\u00AE",
+    "REG": "\u00AE",
+    "reg;": "\u00AE",
+    "reg": "\u00AE",
+    "ReverseElement;": "\u220B",
+    "ReverseEquilibrium;": "\u21CB",
+    "ReverseUpEquilibrium;": "\u296F",
+    "rfisht;": "\u297D",
+    "rfloor;": "\u230B",
+    "Rfr;": "\u211C",
+    "rfr;": "\uD835\uDD2F",
+    "rHar;": "\u2964",
+    "rhard;": "\u21C1",
+    "rharu;": "\u21C0",
+    "rharul;": "\u296C",
+    "Rho;": "\u03A1",
+    "rho;": "\u03C1",
+    "rhov;": "\u03F1",
+    "RightAngleBracket;": "\u27E9",
+    "RightArrow;": "\u2192",
+    "Rightarrow;": "\u21D2",
+    "rightarrow;": "\u2192",
+    "RightArrowBar;": "\u21E5",
+    "RightArrowLeftArrow;": "\u21C4",
+    "rightarrowtail;": "\u21A3",
+    "RightCeiling;": "\u2309",
+    "RightDoubleBracket;": "\u27E7",
+    "RightDownTeeVector;": "\u295D",
+    "RightDownVector;": "\u21C2",
+    "RightDownVectorBar;": "\u2955",
+    "RightFloor;": "\u230B",
+    "rightharpoondown;": "\u21C1",
+    "rightharpoonup;": "\u21C0",
+    "rightleftarrows;": "\u21C4",
+    "rightleftharpoons;": "\u21CC",
+    "rightrightarrows;": "\u21C9",
+    "rightsquigarrow;": "\u219D",
+    "RightTee;": "\u22A2",
+    "RightTeeArrow;": "\u21A6",
+    "RightTeeVector;": "\u295B",
+    "rightthreetimes;": "\u22CC",
+    "RightTriangle;": "\u22B3",
+    "RightTriangleBar;": "\u29D0",
+    "RightTriangleEqual;": "\u22B5",
+    "RightUpDownVector;": "\u294F",
+    "RightUpTeeVector;": "\u295C",
+    "RightUpVector;": "\u21BE",
+    "RightUpVectorBar;": "\u2954",
+    "RightVector;": "\u21C0",
+    "RightVectorBar;": "\u2953",
+    "ring;": "\u02DA",
+    "risingdotseq;": "\u2253",
+    "rlarr;": "\u21C4",
+    "rlhar;": "\u21CC",
+    "rlm;": "\u200F",
+    "rmoust;": "\u23B1",
+    "rmoustache;": "\u23B1",
+    "rnmid;": "\u2AEE",
+    "roang;": "\u27ED",
+    "roarr;": "\u21FE",
+    "robrk;": "\u27E7",
+    "ropar;": "\u2986",
+    "Ropf;": "\u211D",
+    "ropf;": "\uD835\uDD63",
+    "roplus;": "\u2A2E",
+    "rotimes;": "\u2A35",
+    "RoundImplies;": "\u2970",
+    "rpar;": "\u0029",
+    "rpargt;": "\u2994",
+    "rppolint;": "\u2A12",
+    "rrarr;": "\u21C9",
+    "Rrightarrow;": "\u21DB",
+    "rsaquo;": "\u203A",
+    "Rscr;": "\u211B",
+    "rscr;": "\uD835\uDCC7",
+    "Rsh;": "\u21B1",
+    "rsh;": "\u21B1",
+    "rsqb;": "\u005D",
+    "rsquo;": "\u2019",
+    "rsquor;": "\u2019",
+    "rthree;": "\u22CC",
+    "rtimes;": "\u22CA",
+    "rtri;": "\u25B9",
+    "rtrie;": "\u22B5",
+    "rtrif;": "\u25B8",
+    "rtriltri;": "\u29CE",
+    "RuleDelayed;": "\u29F4",
+    "ruluhar;": "\u2968",
+    "rx;": "\u211E",
+    "Sacute;": "\u015A",
+    "sacute;": "\u015B",
+    "sbquo;": "\u201A",
+    "Sc;": "\u2ABC",
+    "sc;": "\u227B",
+    "scap;": "\u2AB8",
+    "Scaron;": "\u0160",
+    "scaron;": "\u0161",
+    "sccue;": "\u227D",
+    "scE;": "\u2AB4",
+    "sce;": "\u2AB0",
+    "Scedil;": "\u015E",
+    "scedil;": "\u015F",
+    "Scirc;": "\u015C",
+    "scirc;": "\u015D",
+    "scnap;": "\u2ABA",
+    "scnE;": "\u2AB6",
+    "scnsim;": "\u22E9",
+    "scpolint;": "\u2A13",
+    "scsim;": "\u227F",
+    "Scy;": "\u0421",
+    "scy;": "\u0441",
+    "sdot;": "\u22C5",
+    "sdotb;": "\u22A1",
+    "sdote;": "\u2A66",
+    "searhk;": "\u2925",
+    "seArr;": "\u21D8",
+    "searr;": "\u2198",
+    "searrow;": "\u2198",
+    "sect;": "\u00A7",
+    "sect": "\u00A7",
+    "semi;": "\u003B",
+    "seswar;": "\u2929",
+    "setminus;": "\u2216",
+    "setmn;": "\u2216",
+    "sext;": "\u2736",
+    "Sfr;": "\uD835\uDD16",
+    "sfr;": "\uD835\uDD30",
+    "sfrown;": "\u2322",
+    "sharp;": "\u266F",
+    "SHCHcy;": "\u0429",
+    "shchcy;": "\u0449",
+    "SHcy;": "\u0428",
+    "shcy;": "\u0448",
+    "ShortDownArrow;": "\u2193",
+    "ShortLeftArrow;": "\u2190",
+    "shortmid;": "\u2223",
+    "shortparallel;": "\u2225",
+    "ShortRightArrow;": "\u2192",
+    "ShortUpArrow;": "\u2191",
+    "shy;": "\u00AD",
+    "shy": "\u00AD",
+    "Sigma;": "\u03A3",
+    "sigma;": "\u03C3",
+    "sigmaf;": "\u03C2",
+    "sigmav;": "\u03C2",
+    "sim;": "\u223C",
+    "simdot;": "\u2A6A",
+    "sime;": "\u2243",
+    "simeq;": "\u2243",
+    "simg;": "\u2A9E",
+    "simgE;": "\u2AA0",
+    "siml;": "\u2A9D",
+    "simlE;": "\u2A9F",
+    "simne;": "\u2246",
+    "simplus;": "\u2A24",
+    "simrarr;": "\u2972",
+    "slarr;": "\u2190",
+    "SmallCircle;": "\u2218",
+    "smallsetminus;": "\u2216",
+    "smashp;": "\u2A33",
+    "smeparsl;": "\u29E4",
+    "smid;": "\u2223",
+    "smile;": "\u2323",
+    "smt;": "\u2AAA",
+    "smte;": "\u2AAC",
+    "smtes;": "\u2AAC\uFE00",
+    "SOFTcy;": "\u042C",
+    "softcy;": "\u044C",
+    "sol;": "\u002F",
+    "solb;": "\u29C4",
+    "solbar;": "\u233F",
+    "Sopf;": "\uD835\uDD4A",
+    "sopf;": "\uD835\uDD64",
+    "spades;": "\u2660",
+    "spadesuit;": "\u2660",
+    "spar;": "\u2225",
+    "sqcap;": "\u2293",
+    "sqcaps;": "\u2293\uFE00",
+    "sqcup;": "\u2294",
+    "sqcups;": "\u2294\uFE00",
+    "Sqrt;": "\u221A",
+    "sqsub;": "\u228F",
+    "sqsube;": "\u2291",
+    "sqsubset;": "\u228F",
+    "sqsubseteq;": "\u2291",
+    "sqsup;": "\u2290",
+    "sqsupe;": "\u2292",
+    "sqsupset;": "\u2290",
+    "sqsupseteq;": "\u2292",
+    "squ;": "\u25A1",
+    "Square;": "\u25A1",
+    "square;": "\u25A1",
+    "SquareIntersection;": "\u2293",
+    "SquareSubset;": "\u228F",
+    "SquareSubsetEqual;": "\u2291",
+    "SquareSuperset;": "\u2290",
+    "SquareSupersetEqual;": "\u2292",
+    "SquareUnion;": "\u2294",
+    "squarf;": "\u25AA",
+    "squf;": "\u25AA",
+    "srarr;": "\u2192",
+    "Sscr;": "\uD835\uDCAE",
+    "sscr;": "\uD835\uDCC8",
+    "ssetmn;": "\u2216",
+    "ssmile;": "\u2323",
+    "sstarf;": "\u22C6",
+    "Star;": "\u22C6",
+    "star;": "\u2606",
+    "starf;": "\u2605",
+    "straightepsilon;": "\u03F5",
+    "straightphi;": "\u03D5",
+    "strns;": "\u00AF",
+    "Sub;": "\u22D0",
+    "sub;": "\u2282",
+    "subdot;": "\u2ABD",
+    "subE;": "\u2AC5",
+    "sube;": "\u2286",
+    "subedot;": "\u2AC3",
+    "submult;": "\u2AC1",
+    "subnE;": "\u2ACB",
+    "subne;": "\u228A",
+    "subplus;": "\u2ABF",
+    "subrarr;": "\u2979",
+    "Subset;": "\u22D0",
+    "subset;": "\u2282",
+    "subseteq;": "\u2286",
+    "subseteqq;": "\u2AC5",
+    "SubsetEqual;": "\u2286",
+    "subsetneq;": "\u228A",
+    "subsetneqq;": "\u2ACB",
+    "subsim;": "\u2AC7",
+    "subsub;": "\u2AD5",
+    "subsup;": "\u2AD3",
+    "succ;": "\u227B",
+    "succapprox;": "\u2AB8",
+    "succcurlyeq;": "\u227D",
+    "Succeeds;": "\u227B",
+    "SucceedsEqual;": "\u2AB0",
+    "SucceedsSlantEqual;": "\u227D",
+    "SucceedsTilde;": "\u227F",
+    "succeq;": "\u2AB0",
+    "succnapprox;": "\u2ABA",
+    "succneqq;": "\u2AB6",
+    "succnsim;": "\u22E9",
+    "succsim;": "\u227F",
+    "SuchThat;": "\u220B",
+    "Sum;": "\u2211",
+    "sum;": "\u2211",
+    "sung;": "\u266A",
+    "Sup;": "\u22D1",
+    "sup;": "\u2283",
+    "sup1;": "\u00B9",
+    "sup1": "\u00B9",
+    "sup2;": "\u00B2",
+    "sup2": "\u00B2",
+    "sup3;": "\u00B3",
+    "sup3": "\u00B3",
+    "supdot;": "\u2ABE",
+    "supdsub;": "\u2AD8",
+    "supE;": "\u2AC6",
+    "supe;": "\u2287",
+    "supedot;": "\u2AC4",
+    "Superset;": "\u2283",
+    "SupersetEqual;": "\u2287",
+    "suphsol;": "\u27C9",
+    "suphsub;": "\u2AD7",
+    "suplarr;": "\u297B",
+    "supmult;": "\u2AC2",
+    "supnE;": "\u2ACC",
+    "supne;": "\u228B",
+    "supplus;": "\u2AC0",
+    "Supset;": "\u22D1",
+    "supset;": "\u2283",
+    "supseteq;": "\u2287",
+    "supseteqq;": "\u2AC6",
+    "supsetneq;": "\u228B",
+    "supsetneqq;": "\u2ACC",
+    "supsim;": "\u2AC8",
+    "supsub;": "\u2AD4",
+    "supsup;": "\u2AD6",
+    "swarhk;": "\u2926",
+    "swArr;": "\u21D9",
+    "swarr;": "\u2199",
+    "swarrow;": "\u2199",
+    "swnwar;": "\u292A",
+    "szlig;": "\u00DF",
+    "szlig": "\u00DF",
+    "Tab;": "\u0009",
+    "target;": "\u2316",
+    "Tau;": "\u03A4",
+    "tau;": "\u03C4",
+    "tbrk;": "\u23B4",
+    "Tcaron;": "\u0164",
+    "tcaron;": "\u0165",
+    "Tcedil;": "\u0162",
+    "tcedil;": "\u0163",
+    "Tcy;": "\u0422",
+    "tcy;": "\u0442",
+    "tdot;": "\u20DB",
+    "telrec;": "\u2315",
+    "Tfr;": "\uD835\uDD17",
+    "tfr;": "\uD835\uDD31",
+    "there4;": "\u2234",
+    "Therefore;": "\u2234",
+    "therefore;": "\u2234",
+    "Theta;": "\u0398",
+    "theta;": "\u03B8",
+    "thetasym;": "\u03D1",
+    "thetav;": "\u03D1",
+    "thickapprox;": "\u2248",
+    "thicksim;": "\u223C",
+    "ThickSpace;": "\u205F\u200A",
+    "thinsp;": "\u2009",
+    "ThinSpace;": "\u2009",
+    "thkap;": "\u2248",
+    "thksim;": "\u223C",
+    "THORN;": "\u00DE",
+    "THORN": "\u00DE",
+    "thorn;": "\u00FE",
+    "thorn": "\u00FE",
+    "Tilde;": "\u223C",
+    "tilde;": "\u02DC",
+    "TildeEqual;": "\u2243",
+    "TildeFullEqual;": "\u2245",
+    "TildeTilde;": "\u2248",
+    "times;": "\u00D7",
+    "times": "\u00D7",
+    "timesb;": "\u22A0",
+    "timesbar;": "\u2A31",
+    "timesd;": "\u2A30",
+    "tint;": "\u222D",
+    "toea;": "\u2928",
+    "top;": "\u22A4",
+    "topbot;": "\u2336",
+    "topcir;": "\u2AF1",
+    "Topf;": "\uD835\uDD4B",
+    "topf;": "\uD835\uDD65",
+    "topfork;": "\u2ADA",
+    "tosa;": "\u2929",
+    "tprime;": "\u2034",
+    "TRADE;": "\u2122",
+    "trade;": "\u2122",
+    "triangle;": "\u25B5",
+    "triangledown;": "\u25BF",
+    "triangleleft;": "\u25C3",
+    "trianglelefteq;": "\u22B4",
+    "triangleq;": "\u225C",
+    "triangleright;": "\u25B9",
+    "trianglerighteq;": "\u22B5",
+    "tridot;": "\u25EC",
+    "trie;": "\u225C",
+    "triminus;": "\u2A3A",
+    "TripleDot;": "\u20DB",
+    "triplus;": "\u2A39",
+    "trisb;": "\u29CD",
+    "tritime;": "\u2A3B",
+    "trpezium;": "\u23E2",
+    "Tscr;": "\uD835\uDCAF",
+    "tscr;": "\uD835\uDCC9",
+    "TScy;": "\u0426",
+    "tscy;": "\u0446",
+    "TSHcy;": "\u040B",
+    "tshcy;": "\u045B",
+    "Tstrok;": "\u0166",
+    "tstrok;": "\u0167",
+    "twixt;": "\u226C",
+    "twoheadleftarrow;": "\u219E",
+    "twoheadrightarrow;": "\u21A0",
+    "Uacute;": "\u00DA",
+    "Uacute": "\u00DA",
+    "uacute;": "\u00FA",
+    "uacute": "\u00FA",
+    "Uarr;": "\u219F",
+    "uArr;": "\u21D1",
+    "uarr;": "\u2191",
+    "Uarrocir;": "\u2949",
+    "Ubrcy;": "\u040E",
+    "ubrcy;": "\u045E",
+    "Ubreve;": "\u016C",
+    "ubreve;": "\u016D",
+    "Ucirc;": "\u00DB",
+    "Ucirc": "\u00DB",
+    "ucirc;": "\u00FB",
+    "ucirc": "\u00FB",
+    "Ucy;": "\u0423",
+    "ucy;": "\u0443",
+    "udarr;": "\u21C5",
+    "Udblac;": "\u0170",
+    "udblac;": "\u0171",
+    "udhar;": "\u296E",
+    "ufisht;": "\u297E",
+    "Ufr;": "\uD835\uDD18",
+    "ufr;": "\uD835\uDD32",
+    "Ugrave;": "\u00D9",
+    "Ugrave": "\u00D9",
+    "ugrave;": "\u00F9",
+    "ugrave": "\u00F9",
+    "uHar;": "\u2963",
+    "uharl;": "\u21BF",
+    "uharr;": "\u21BE",
+    "uhblk;": "\u2580",
+    "ulcorn;": "\u231C",
+    "ulcorner;": "\u231C",
+    "ulcrop;": "\u230F",
+    "ultri;": "\u25F8",
+    "Umacr;": "\u016A",
+    "umacr;": "\u016B",
+    "uml;": "\u00A8",
+    "uml": "\u00A8",
+    "UnderBar;": "\u005F",
+    "UnderBrace;": "\u23DF",
+    "UnderBracket;": "\u23B5",
+    "UnderParenthesis;": "\u23DD",
+    "Union;": "\u22C3",
+    "UnionPlus;": "\u228E",
+    "Uogon;": "\u0172",
+    "uogon;": "\u0173",
+    "Uopf;": "\uD835\uDD4C",
+    "uopf;": "\uD835\uDD66",
+    "UpArrow;": "\u2191",
+    "Uparrow;": "\u21D1",
+    "uparrow;": "\u2191",
+    "UpArrowBar;": "\u2912",
+    "UpArrowDownArrow;": "\u21C5",
+    "UpDownArrow;": "\u2195",
+    "Updownarrow;": "\u21D5",
+    "updownarrow;": "\u2195",
+    "UpEquilibrium;": "\u296E",
+    "upharpoonleft;": "\u21BF",
+    "upharpoonright;": "\u21BE",
+    "uplus;": "\u228E",
+    "UpperLeftArrow;": "\u2196",
+    "UpperRightArrow;": "\u2197",
+    "Upsi;": "\u03D2",
+    "upsi;": "\u03C5",
+    "upsih;": "\u03D2",
+    "Upsilon;": "\u03A5",
+    "upsilon;": "\u03C5",
+    "UpTee;": "\u22A5",
+    "UpTeeArrow;": "\u21A5",
+    "upuparrows;": "\u21C8",
+    "urcorn;": "\u231D",
+    "urcorner;": "\u231D",
+    "urcrop;": "\u230E",
+    "Uring;": "\u016E",
+    "uring;": "\u016F",
+    "urtri;": "\u25F9",
+    "Uscr;": "\uD835\uDCB0",
+    "uscr;": "\uD835\uDCCA",
+    "utdot;": "\u22F0",
+    "Utilde;": "\u0168",
+    "utilde;": "\u0169",
+    "utri;": "\u25B5",
+    "utrif;": "\u25B4",
+    "uuarr;": "\u21C8",
+    "Uuml;": "\u00DC",
+    "Uuml": "\u00DC",
+    "uuml;": "\u00FC",
+    "uuml": "\u00FC",
+    "uwangle;": "\u29A7",
+    "vangrt;": "\u299C",
+    "varepsilon;": "\u03F5",
+    "varkappa;": "\u03F0",
+    "varnothing;": "\u2205",
+    "varphi;": "\u03D5",
+    "varpi;": "\u03D6",
+    "varpropto;": "\u221D",
+    "vArr;": "\u21D5",
+    "varr;": "\u2195",
+    "varrho;": "\u03F1",
+    "varsigma;": "\u03C2",
+    "varsubsetneq;": "\u228A\uFE00",
+    "varsubsetneqq;": "\u2ACB\uFE00",
+    "varsupsetneq;": "\u228B\uFE00",
+    "varsupsetneqq;": "\u2ACC\uFE00",
+    "vartheta;": "\u03D1",
+    "vartriangleleft;": "\u22B2",
+    "vartriangleright;": "\u22B3",
+    "Vbar;": "\u2AEB",
+    "vBar;": "\u2AE8",
+    "vBarv;": "\u2AE9",
+    "Vcy;": "\u0412",
+    "vcy;": "\u0432",
+    "VDash;": "\u22AB",
+    "Vdash;": "\u22A9",
+    "vDash;": "\u22A8",
+    "vdash;": "\u22A2",
+    "Vdashl;": "\u2AE6",
+    "Vee;": "\u22C1",
+    "vee;": "\u2228",
+    "veebar;": "\u22BB",
+    "veeeq;": "\u225A",
+    "vellip;": "\u22EE",
+    "Verbar;": "\u2016",
+    "verbar;": "\u007C",
+    "Vert;": "\u2016",
+    "vert;": "\u007C",
+    "VerticalBar;": "\u2223",
+    "VerticalLine;": "\u007C",
+    "VerticalSeparator;": "\u2758",
+    "VerticalTilde;": "\u2240",
+    "VeryThinSpace;": "\u200A",
+    "Vfr;": "\uD835\uDD19",
+    "vfr;": "\uD835\uDD33",
+    "vltri;": "\u22B2",
+    "vnsub;": "\u2282\u20D2",
+    "vnsup;": "\u2283\u20D2",
+    "Vopf;": "\uD835\uDD4D",
+    "vopf;": "\uD835\uDD67",
+    "vprop;": "\u221D",
+    "vrtri;": "\u22B3",
+    "Vscr;": "\uD835\uDCB1",
+    "vscr;": "\uD835\uDCCB",
+    "vsubnE;": "\u2ACB\uFE00",
+    "vsubne;": "\u228A\uFE00",
+    "vsupnE;": "\u2ACC\uFE00",
+    "vsupne;": "\u228B\uFE00",
+    "Vvdash;": "\u22AA",
+    "vzigzag;": "\u299A",
+    "Wcirc;": "\u0174",
+    "wcirc;": "\u0175",
+    "wedbar;": "\u2A5F",
+    "Wedge;": "\u22C0",
+    "wedge;": "\u2227",
+    "wedgeq;": "\u2259",
+    "weierp;": "\u2118",
+    "Wfr;": "\uD835\uDD1A",
+    "wfr;": "\uD835\uDD34",
+    "Wopf;": "\uD835\uDD4E",
+    "wopf;": "\uD835\uDD68",
+    "wp;": "\u2118",
+    "wr;": "\u2240",
+    "wreath;": "\u2240",
+    "Wscr;": "\uD835\uDCB2",
+    "wscr;": "\uD835\uDCCC",
+    "xcap;": "\u22C2",
+    "xcirc;": "\u25EF",
+    "xcup;": "\u22C3",
+    "xdtri;": "\u25BD",
+    "Xfr;": "\uD835\uDD1B",
+    "xfr;": "\uD835\uDD35",
+    "xhArr;": "\u27FA",
+    "xharr;": "\u27F7",
+    "Xi;": "\u039E",
+    "xi;": "\u03BE",
+    "xlArr;": "\u27F8",
+    "xlarr;": "\u27F5",
+    "xmap;": "\u27FC",
+    "xnis;": "\u22FB",
+    "xodot;": "\u2A00",
+    "Xopf;": "\uD835\uDD4F",
+    "xopf;": "\uD835\uDD69",
+    "xoplus;": "\u2A01",
+    "xotime;": "\u2A02",
+    "xrArr;": "\u27F9",
+    "xrarr;": "\u27F6",
+    "Xscr;": "\uD835\uDCB3",
+    "xscr;": "\uD835\uDCCD",
+    "xsqcup;": "\u2A06",
+    "xuplus;": "\u2A04",
+    "xutri;": "\u25B3",
+    "xvee;": "\u22C1",
+    "xwedge;": "\u22C0",
+    "Yacute;": "\u00DD",
+    "Yacute": "\u00DD",
+    "yacute;": "\u00FD",
+    "yacute": "\u00FD",
+    "YAcy;": "\u042F",
+    "yacy;": "\u044F",
+    "Ycirc;": "\u0176",
+    "ycirc;": "\u0177",
+    "Ycy;": "\u042B",
+    "ycy;": "\u044B",
+    "yen;": "\u00A5",
+    "yen": "\u00A5",
+    "Yfr;": "\uD835\uDD1C",
+    "yfr;": "\uD835\uDD36",
+    "YIcy;": "\u0407",
+    "yicy;": "\u0457",
+    "Yopf;": "\uD835\uDD50",
+    "yopf;": "\uD835\uDD6A",
+    "Yscr;": "\uD835\uDCB4",
+    "yscr;": "\uD835\uDCCE",
+    "YUcy;": "\u042E",
+    "yucy;": "\u044E",
+    "Yuml;": "\u0178",
+    "yuml;": "\u00FF",
+    "yuml": "\u00FF",
+    "Zacute;": "\u0179",
+    "zacute;": "\u017A",
+    "Zcaron;": "\u017D",
+    "zcaron;": "\u017E",
+    "Zcy;": "\u0417",
+    "zcy;": "\u0437",
+    "Zdot;": "\u017B",
+    "zdot;": "\u017C",
+    "zeetrf;": "\u2128",
+    "ZeroWidthSpace;": "\u200B",
+    "Zeta;": "\u0396",
+    "zeta;": "\u03B6",
+    "Zfr;": "\u2128",
+    "zfr;": "\uD835\uDD37",
+    "ZHcy;": "\u0416",
+    "zhcy;": "\u0436",
+    "zigrarr;": "\u21DD",
+    "Zopf;": "\u2124",
+    "zopf;": "\uD835\uDD6B",
+    "Zscr;": "\uD835\uDCB5",
+    "zscr;": "\uD835\uDCCF",
+    "zwj;": "\u200D",
+    "zwnj;": "\u200C"
+};

Java开发环境安装/eclipse-jee-2024-06-R-win32-x86_64/eclipse/plugins/org.eclipse.wildwebdeveloper_1.2.2.202405280856/node_modules/volar-service-html/node_modules/vscode-html-languageservice/lib/esm/parser/htmlParser.js

@@ -1,3 +1,161 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:ed9f98b9b57ec1e2bb057693cc7d78e13faaefa86873f8e7cb7c6d4c114a26f9
-size 6730
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import { createScanner } from './htmlScanner';
+import { findFirst } from '../utils/arrays';
+import { TokenType } from '../htmlLanguageTypes';
+export class Node {
+    get attributeNames() { return this.attributes ? Object.keys(this.attributes) : []; }
+    constructor(start, end, children, parent) {
+        this.start = start;
+        this.end = end;
+        this.children = children;
+        this.parent = parent;
+        this.closed = false;
+    }
+    isSameTag(tagInLowerCase) {
+        if (this.tag === undefined) {
+            return tagInLowerCase === undefined;
+        }
+        else {
+            return tagInLowerCase !== undefined && this.tag.length === tagInLowerCase.length && this.tag.toLowerCase() === tagInLowerCase;
+        }
+    }
+    get firstChild() { return this.children[0]; }
+    get lastChild() { return this.children.length ? this.children[this.children.length - 1] : void 0; }
+    findNodeBefore(offset) {
+        const idx = findFirst(this.children, c => offset <= c.start) - 1;
+        if (idx >= 0) {
+            const child = this.children[idx];
+            if (offset > child.start) {
+                if (offset < child.end) {
+                    return child.findNodeBefore(offset);
+                }
+                const lastChild = child.lastChild;
+                if (lastChild && lastChild.end === child.end) {
+                    return child.findNodeBefore(offset);
+                }
+                return child;
+            }
+        }
+        return this;
+    }
+    findNodeAt(offset) {
+        const idx = findFirst(this.children, c => offset <= c.start) - 1;
+        if (idx >= 0) {
+            const child = this.children[idx];
+            if (offset > child.start && offset <= child.end) {
+                return child.findNodeAt(offset);
+            }
+        }
+        return this;
+    }
+}
+export class HTMLParser {
+    constructor(dataManager) {
+        this.dataManager = dataManager;
+    }
+    parseDocument(document) {
+        return this.parse(document.getText(), this.dataManager.getVoidElements(document.languageId));
+    }
+    parse(text, voidElements) {
+        const scanner = createScanner(text, undefined, undefined, true);
+        const htmlDocument = new Node(0, text.length, [], void 0);
+        let curr = htmlDocument;
+        let endTagStart = -1;
+        let endTagName = undefined;
+        let pendingAttribute = null;
+        let token = scanner.scan();
+        while (token !== TokenType.EOS) {
+            switch (token) {
+                case TokenType.StartTagOpen:
+                    const child = new Node(scanner.getTokenOffset(), text.length, [], curr);
+                    curr.children.push(child);
+                    curr = child;
+                    break;
+                case TokenType.StartTag:
+                    curr.tag = scanner.getTokenText();
+                    break;
+                case TokenType.StartTagClose:
+                    if (curr.parent) {
+                        curr.end = scanner.getTokenEnd(); // might be later set to end tag position
+                        if (scanner.getTokenLength()) {
+                            curr.startTagEnd = scanner.getTokenEnd();
+                            if (curr.tag && this.dataManager.isVoidElement(curr.tag, voidElements)) {
+                                curr.closed = true;
+                                curr = curr.parent;
+                            }
+                        }
+                        else {
+                            // pseudo close token from an incomplete start tag
+                            curr = curr.parent;
+                        }
+                    }
+                    break;
+                case TokenType.StartTagSelfClose:
+                    if (curr.parent) {
+                        curr.closed = true;
+                        curr.end = scanner.getTokenEnd();
+                        curr.startTagEnd = scanner.getTokenEnd();
+                        curr = curr.parent;
+                    }
+                    break;
+                case TokenType.EndTagOpen:
+                    endTagStart = scanner.getTokenOffset();
+                    endTagName = undefined;
+                    break;
+                case TokenType.EndTag:
+                    endTagName = scanner.getTokenText().toLowerCase();
+                    break;
+                case TokenType.EndTagClose:
+                    let node = curr;
+                    // see if we can find a matching tag
+                    while (!node.isSameTag(endTagName) && node.parent) {
+                        node = node.parent;
+                    }
+                    if (node.parent) {
+                        while (curr !== node) {
+                            curr.end = endTagStart;
+                            curr.closed = false;
+                            curr = curr.parent;
+                        }
+                        curr.closed = true;
+                        curr.endTagStart = endTagStart;
+                        curr.end = scanner.getTokenEnd();
+                        curr = curr.parent;
+                    }
+                    break;
+                case TokenType.AttributeName: {
+                    pendingAttribute = scanner.getTokenText();
+                    let attributes = curr.attributes;
+                    if (!attributes) {
+                        curr.attributes = attributes = {};
+                    }
+                    attributes[pendingAttribute] = null; // Support valueless attributes such as 'checked'
+                    break;
+                }
+                case TokenType.AttributeValue: {
+                    const value = scanner.getTokenText();
+                    const attributes = curr.attributes;
+                    if (attributes && pendingAttribute) {
+                        attributes[pendingAttribute] = value;
+                        pendingAttribute = null;
+                    }
+                    break;
+                }
+            }
+            token = scanner.scan();
+        }
+        while (curr.parent) {
+            curr.end = text.length;
+            curr.closed = false;
+            curr = curr.parent;
+        }
+        return {
+            roots: htmlDocument.children,
+            findNodeBefore: htmlDocument.findNodeBefore.bind(htmlDocument),
+            findNodeAt: htmlDocument.findNodeAt.bind(htmlDocument)
+        };
+    }
+}

Java开发环境安装/eclipse-jee-2024-06-R-win32-x86_64/eclipse/plugins/org.eclipse.wildwebdeveloper_1.2.2.202405280856/node_modules/volar-service-html/node_modules/vscode-html-languageservice/lib/esm/parser/htmlScanner.d.ts

@@ -1,3 +1,2 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:86b34ad371950cd7d4551eb2acd9d4460155c8d722af224bee1600e2143668ba
-size 209
+import { ScannerState, Scanner } from '../htmlLanguageTypes';
+export declare function createScanner(input: string, initialOffset?: number, initialState?: ScannerState, emitPseudoCloseTags?: boolean): Scanner;

Java开发环境安装/eclipse-jee-2024-06-R-win32-x86_64/eclipse/plugins/org.eclipse.wildwebdeveloper_1.2.2.202405280856/node_modules/volar-service-html/node_modules/vscode-html-languageservice/lib/esm/parser/htmlScanner.js

@@ -1,3 +1,403 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:c476d3da556a01173f4e4bbdbdc6d264f2fa92c3aecfae10d682058260fff388
-size 17018
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import * as l10n from '@vscode/l10n';
+import { TokenType, ScannerState } from '../htmlLanguageTypes';
+class MultiLineStream {
+    constructor(source, position) {
+        this.source = source;
+        this.len = source.length;
+        this.position = position;
+    }
+    eos() {
+        return this.len <= this.position;
+    }
+    getSource() {
+        return this.source;
+    }
+    pos() {
+        return this.position;
+    }
+    goBackTo(pos) {
+        this.position = pos;
+    }
+    goBack(n) {
+        this.position -= n;
+    }
+    advance(n) {
+        this.position += n;
+    }
+    goToEnd() {
+        this.position = this.source.length;
+    }
+    nextChar() {
+        return this.source.charCodeAt(this.position++) || 0;
+    }
+    peekChar(n = 0) {
+        return this.source.charCodeAt(this.position + n) || 0;
+    }
+    advanceIfChar(ch) {
+        if (ch === this.source.charCodeAt(this.position)) {
+            this.position++;
+            return true;
+        }
+        return false;
+    }
+    advanceIfChars(ch) {
+        let i;
+        if (this.position + ch.length > this.source.length) {
+            return false;
+        }
+        for (i = 0; i < ch.length; i++) {
+            if (this.source.charCodeAt(this.position + i) !== ch[i]) {
+                return false;
+            }
+        }
+        this.advance(i);
+        return true;
+    }
+    advanceIfRegExp(regex) {
+        const str = this.source.substr(this.position);
+        const match = str.match(regex);
+        if (match) {
+            this.position = this.position + match.index + match[0].length;
+            return match[0];
+        }
+        return '';
+    }
+    advanceUntilRegExp(regex) {
+        const str = this.source.substr(this.position);
+        const match = str.match(regex);
+        if (match) {
+            this.position = this.position + match.index;
+            return match[0];
+        }
+        else {
+            this.goToEnd();
+        }
+        return '';
+    }
+    advanceUntilChar(ch) {
+        while (this.position < this.source.length) {
+            if (this.source.charCodeAt(this.position) === ch) {
+                return true;
+            }
+            this.advance(1);
+        }
+        return false;
+    }
+    advanceUntilChars(ch) {
+        while (this.position + ch.length <= this.source.length) {
+            let i = 0;
+            for (; i < ch.length && this.source.charCodeAt(this.position + i) === ch[i]; i++) {
+            }
+            if (i === ch.length) {
+                return true;
+            }
+            this.advance(1);
+        }
+        this.goToEnd();
+        return false;
+    }
+    skipWhitespace() {
+        const n = this.advanceWhileChar(ch => {
+            return ch === _WSP || ch === _TAB || ch === _NWL || ch === _LFD || ch === _CAR;
+        });
+        return n > 0;
+    }
+    advanceWhileChar(condition) {
+        const posNow = this.position;
+        while (this.position < this.len && condition(this.source.charCodeAt(this.position))) {
+            this.position++;
+        }
+        return this.position - posNow;
+    }
+}
+const _BNG = '!'.charCodeAt(0);
+const _MIN = '-'.charCodeAt(0);
+const _LAN = '<'.charCodeAt(0);
+const _RAN = '>'.charCodeAt(0);
+const _FSL = '/'.charCodeAt(0);
+const _EQS = '='.charCodeAt(0);
+const _DQO = '"'.charCodeAt(0);
+const _SQO = '\''.charCodeAt(0);
+const _NWL = '\n'.charCodeAt(0);
+const _CAR = '\r'.charCodeAt(0);
+const _LFD = '\f'.charCodeAt(0);
+const _WSP = ' '.charCodeAt(0);
+const _TAB = '\t'.charCodeAt(0);
+const htmlScriptContents = {
+    'text/x-handlebars-template': true,
+    // Fix for https://github.com/microsoft/vscode/issues/77977
+    'text/html': true,
+};
+export function createScanner(input, initialOffset = 0, initialState = ScannerState.WithinContent, emitPseudoCloseTags = false) {
+    const stream = new MultiLineStream(input, initialOffset);
+    let state = initialState;
+    let tokenOffset = 0;
+    let tokenType = TokenType.Unknown;
+    let tokenError;
+    let hasSpaceAfterTag;
+    let lastTag;
+    let lastAttributeName;
+    let lastTypeValue;
+    function nextElementName() {
+        return stream.advanceIfRegExp(/^[_:\w][_:\w-.\d]*/).toLowerCase();
+    }
+    function nextAttributeName() {
+        return stream.advanceIfRegExp(/^[^\s"'></=\x00-\x0F\x7F\x80-\x9F]*/).toLowerCase();
+    }
+    function finishToken(offset, type, errorMessage) {
+        tokenType = type;
+        tokenOffset = offset;
+        tokenError = errorMessage;
+        return type;
+    }
+    function scan() {
+        const offset = stream.pos();
+        const oldState = state;
+        const token = internalScan();
+        if (token !== TokenType.EOS && offset === stream.pos() && !(emitPseudoCloseTags && (token === TokenType.StartTagClose || token === TokenType.EndTagClose))) {
+            console.warn('Scanner.scan has not advanced at offset ' + offset + ', state before: ' + oldState + ' after: ' + state);
+            stream.advance(1);
+            return finishToken(offset, TokenType.Unknown);
+        }
+        return token;
+    }
+    function internalScan() {
+        const offset = stream.pos();
+        if (stream.eos()) {
+            return finishToken(offset, TokenType.EOS);
+        }
+        let errorMessage;
+        switch (state) {
+            case ScannerState.WithinComment:
+                if (stream.advanceIfChars([_MIN, _MIN, _RAN])) { // -->
+                    state = ScannerState.WithinContent;
+                    return finishToken(offset, TokenType.EndCommentTag);
+                }
+                stream.advanceUntilChars([_MIN, _MIN, _RAN]); // -->
+                return finishToken(offset, TokenType.Comment);
+            case ScannerState.WithinDoctype:
+                if (stream.advanceIfChar(_RAN)) {
+                    state = ScannerState.WithinContent;
+                    return finishToken(offset, TokenType.EndDoctypeTag);
+                }
+                stream.advanceUntilChar(_RAN); // >
+                return finishToken(offset, TokenType.Doctype);
+            case ScannerState.WithinContent:
+                if (stream.advanceIfChar(_LAN)) { // <
+                    if (!stream.eos() && stream.peekChar() === _BNG) { // !
+                        if (stream.advanceIfChars([_BNG, _MIN, _MIN])) { // <!--
+                            state = ScannerState.WithinComment;
+                            return finishToken(offset, TokenType.StartCommentTag);
+                        }
+                        if (stream.advanceIfRegExp(/^!doctype/i)) {
+                            state = ScannerState.WithinDoctype;
+                            return finishToken(offset, TokenType.StartDoctypeTag);
+                        }
+                    }
+                    if (stream.advanceIfChar(_FSL)) { // /
+                        state = ScannerState.AfterOpeningEndTag;
+                        return finishToken(offset, TokenType.EndTagOpen);
+                    }
+                    state = ScannerState.AfterOpeningStartTag;
+                    return finishToken(offset, TokenType.StartTagOpen);
+                }
+                stream.advanceUntilChar(_LAN);
+                return finishToken(offset, TokenType.Content);
+            case ScannerState.AfterOpeningEndTag:
+                const tagName = nextElementName();
+                if (tagName.length > 0) {
+                    state = ScannerState.WithinEndTag;
+                    return finishToken(offset, TokenType.EndTag);
+                }
+                if (stream.skipWhitespace()) { // white space is not valid here
+                    return finishToken(offset, TokenType.Whitespace, l10n.t('Tag name must directly follow the open bracket.'));
+                }
+                state = ScannerState.WithinEndTag;
+                stream.advanceUntilChar(_RAN);
+                if (offset < stream.pos()) {
+                    return finishToken(offset, TokenType.Unknown, l10n.t('End tag name expected.'));
+                }
+                return internalScan();
+            case ScannerState.WithinEndTag:
+                if (stream.skipWhitespace()) { // white space is valid here
+                    return finishToken(offset, TokenType.Whitespace);
+                }
+                if (stream.advanceIfChar(_RAN)) { // >
+                    state = ScannerState.WithinContent;
+                    return finishToken(offset, TokenType.EndTagClose);
+                }
+                if (emitPseudoCloseTags && stream.peekChar() === _LAN) { // <
+                    state = ScannerState.WithinContent;
+                    return finishToken(offset, TokenType.EndTagClose, l10n.t('Closing bracket missing.'));
+                }
+                errorMessage = l10n.t('Closing bracket expected.');
+                break;
+            case ScannerState.AfterOpeningStartTag:
+                lastTag = nextElementName();
+                lastTypeValue = void 0;
+                lastAttributeName = void 0;
+                if (lastTag.length > 0) {
+                    hasSpaceAfterTag = false;
+                    state = ScannerState.WithinTag;
+                    return finishToken(offset, TokenType.StartTag);
+                }
+                if (stream.skipWhitespace()) { // white space is not valid here
+                    return finishToken(offset, TokenType.Whitespace, l10n.t('Tag name must directly follow the open bracket.'));
+                }
+                state = ScannerState.WithinTag;
+                stream.advanceUntilChar(_RAN);
+                if (offset < stream.pos()) {
+                    return finishToken(offset, TokenType.Unknown, l10n.t('Start tag name expected.'));
+                }
+                return internalScan();
+            case ScannerState.WithinTag:
+                if (stream.skipWhitespace()) {
+                    hasSpaceAfterTag = true; // remember that we have seen a whitespace
+                    return finishToken(offset, TokenType.Whitespace);
+                }
+                if (hasSpaceAfterTag) {
+                    lastAttributeName = nextAttributeName();
+                    if (lastAttributeName.length > 0) {
+                        state = ScannerState.AfterAttributeName;
+                        hasSpaceAfterTag = false;
+                        return finishToken(offset, TokenType.AttributeName);
+                    }
+                }
+                if (stream.advanceIfChars([_FSL, _RAN])) { // />
+                    state = ScannerState.WithinContent;
+                    return finishToken(offset, TokenType.StartTagSelfClose);
+                }
+                if (stream.advanceIfChar(_RAN)) { // >
+                    if (lastTag === 'script') {
+                        if (lastTypeValue && htmlScriptContents[lastTypeValue]) {
+                            // stay in html
+                            state = ScannerState.WithinContent;
+                        }
+                        else {
+                            state = ScannerState.WithinScriptContent;
+                        }
+                    }
+                    else if (lastTag === 'style') {
+                        state = ScannerState.WithinStyleContent;
+                    }
+                    else {
+                        state = ScannerState.WithinContent;
+                    }
+                    return finishToken(offset, TokenType.StartTagClose);
+                }
+                if (emitPseudoCloseTags && stream.peekChar() === _LAN) { // <
+                    state = ScannerState.WithinContent;
+                    return finishToken(offset, TokenType.StartTagClose, l10n.t('Closing bracket missing.'));
+                }
+                stream.advance(1);
+                return finishToken(offset, TokenType.Unknown, l10n.t('Unexpected character in tag.'));
+            case ScannerState.AfterAttributeName:
+                if (stream.skipWhitespace()) {
+                    hasSpaceAfterTag = true;
+                    return finishToken(offset, TokenType.Whitespace);
+                }
+                if (stream.advanceIfChar(_EQS)) {
+                    state = ScannerState.BeforeAttributeValue;
+                    return finishToken(offset, TokenType.DelimiterAssign);
+                }
+                state = ScannerState.WithinTag;
+                return internalScan(); // no advance yet - jump to WithinTag
+            case ScannerState.BeforeAttributeValue:
+                if (stream.skipWhitespace()) {
+                    return finishToken(offset, TokenType.Whitespace);
+                }
+                let attributeValue = stream.advanceIfRegExp(/^[^\s"'`=<>]+/);
+                if (attributeValue.length > 0) {
+                    if (stream.peekChar() === _RAN && stream.peekChar(-1) === _FSL) { // <foo bar=http://foo/>
+                        stream.goBack(1);
+                        attributeValue = attributeValue.substring(0, attributeValue.length - 1);
+                    }
+                    if (lastAttributeName === 'type') {
+                        lastTypeValue = attributeValue;
+                    }
+                    if (attributeValue.length > 0) {
+                        state = ScannerState.WithinTag;
+                        hasSpaceAfterTag = false;
+                        return finishToken(offset, TokenType.AttributeValue);
+                    }
+                }
+                const ch = stream.peekChar();
+                if (ch === _SQO || ch === _DQO) {
+                    stream.advance(1); // consume quote
+                    if (stream.advanceUntilChar(ch)) {
+                        stream.advance(1); // consume quote
+                    }
+                    if (lastAttributeName === 'type') {
+                        lastTypeValue = stream.getSource().substring(offset + 1, stream.pos() - 1);
+                    }
+                    state = ScannerState.WithinTag;
+                    hasSpaceAfterTag = false;
+                    return finishToken(offset, TokenType.AttributeValue);
+                }
+                state = ScannerState.WithinTag;
+                hasSpaceAfterTag = false;
+                return internalScan(); // no advance yet - jump to WithinTag
+            case ScannerState.WithinScriptContent:
+                // see http://stackoverflow.com/questions/14574471/how-do-browsers-parse-a-script-tag-exactly
+                let sciptState = 1;
+                while (!stream.eos()) {
+                    const match = stream.advanceIfRegExp(/<!--|-->|<\/?script\s*\/?>?/i);
+                    if (match.length === 0) {
+                        stream.goToEnd();
+                        return finishToken(offset, TokenType.Script);
+                    }
+                    else if (match === '<!--') {
+                        if (sciptState === 1) {
+                            sciptState = 2;
+                        }
+                    }
+                    else if (match === '-->') {
+                        sciptState = 1;
+                    }
+                    else if (match[1] !== '/') { // <script
+                        if (sciptState === 2) {
+                            sciptState = 3;
+                        }
+                    }
+                    else { // </script
+                        if (sciptState === 3) {
+                            sciptState = 2;
+                        }
+                        else {
+                            stream.goBack(match.length); // to the beginning of the closing tag
+                            break;
+                        }
+                    }
+                }
+                state = ScannerState.WithinContent;
+                if (offset < stream.pos()) {
+                    return finishToken(offset, TokenType.Script);
+                }
+                return internalScan(); // no advance yet - jump to content
+            case ScannerState.WithinStyleContent:
+                stream.advanceUntilRegExp(/<\/style/i);
+                state = ScannerState.WithinContent;
+                if (offset < stream.pos()) {
+                    return finishToken(offset, TokenType.Styles);
+                }
+                return internalScan(); // no advance yet - jump to content
+        }
+        stream.advance(1);
+        state = ScannerState.WithinContent;
+        return finishToken(offset, TokenType.Unknown, errorMessage);
+    }
+    return {
+        scan,
+        getTokenType: () => tokenType,
+        getTokenOffset: () => tokenOffset,
+        getTokenLength: () => stream.pos() - tokenOffset,
+        getTokenEnd: () => stream.pos(),
+        getTokenText: () => stream.getSource().substring(tokenOffset, stream.pos()),
+        getScannerState: () => state,
+        getTokenError: () => tokenError
+    };
+}

Java开发环境安装/eclipse-jee-2024-06-R-win32-x86_64/eclipse/plugins/org.eclipse.wildwebdeveloper_1.2.2.202405280856/node_modules/volar-service-html/node_modules/vscode-html-languageservice/lib/esm/services/htmlCompletion.js

@@ -1,3 +1,579 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:ad1170a5d3ae8ccea149e0e388cea5347c0733c529bcfcb1f53ed0980b2c2547
-size 27444
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import { createScanner } from '../parser/htmlScanner';
+import { ScannerState, TokenType, Position, CompletionItemKind, Range, TextEdit, InsertTextFormat, MarkupKind } from '../htmlLanguageTypes';
+import { entities } from '../parser/htmlEntities';
+import * as l10n from '@vscode/l10n';
+import { isLetterOrDigit, endsWith, startsWith } from '../utils/strings';
+import { isDefined } from '../utils/object';
+import { generateDocumentation } from '../languageFacts/dataProvider';
+import { PathCompletionParticipant } from './pathCompletion';
+export class HTMLCompletion {
+    constructor(lsOptions, dataManager) {
+        this.lsOptions = lsOptions;
+        this.dataManager = dataManager;
+        this.completionParticipants = [];
+    }
+    setCompletionParticipants(registeredCompletionParticipants) {
+        this.completionParticipants = registeredCompletionParticipants || [];
+    }
+    async doComplete2(document, position, htmlDocument, documentContext, settings) {
+        if (!this.lsOptions.fileSystemProvider || !this.lsOptions.fileSystemProvider.readDirectory) {
+            return this.doComplete(document, position, htmlDocument, settings);
+        }
+        const participant = new PathCompletionParticipant(this.dataManager, this.lsOptions.fileSystemProvider.readDirectory);
+        const contributedParticipants = this.completionParticipants;
+        this.completionParticipants = [participant].concat(contributedParticipants);
+        const result = this.doComplete(document, position, htmlDocument, settings);
+        try {
+            const pathCompletionResult = await participant.computeCompletions(document, documentContext);
+            return {
+                isIncomplete: result.isIncomplete || pathCompletionResult.isIncomplete,
+                items: pathCompletionResult.items.concat(result.items)
+            };
+        }
+        finally {
+            this.completionParticipants = contributedParticipants;
+        }
+    }
+    doComplete(document, position, htmlDocument, settings) {
+        const result = this._doComplete(document, position, htmlDocument, settings);
+        return this.convertCompletionList(result);
+    }
+    _doComplete(document, position, htmlDocument, settings) {
+        const result = {
+            isIncomplete: false,
+            items: []
+        };
+        const completionParticipants = this.completionParticipants;
+        const dataProviders = this.dataManager.getDataProviders().filter(p => p.isApplicable(document.languageId) && (!settings || settings[p.getId()] !== false));
+        const doesSupportMarkdown = this.doesSupportMarkdown();
+        const text = document.getText();
+        const offset = document.offsetAt(position);
+        const node = htmlDocument.findNodeBefore(offset);
+        if (!node) {
+            return result;
+        }
+        const scanner = createScanner(text, node.start);
+        let currentTag = '';
+        let currentAttributeName;
+        let voidElements;
+        function getReplaceRange(replaceStart, replaceEnd = offset) {
+            if (replaceStart > offset) {
+                replaceStart = offset;
+            }
+            return { start: document.positionAt(replaceStart), end: document.positionAt(replaceEnd) };
+        }
+        function collectOpenTagSuggestions(afterOpenBracket, tagNameEnd) {
+            const range = getReplaceRange(afterOpenBracket, tagNameEnd);
+            dataProviders.forEach((provider) => {
+                provider.provideTags().forEach(tag => {
+                    result.items.push({
+                        label: tag.name,
+                        kind: CompletionItemKind.Property,
+                        documentation: generateDocumentation(tag, undefined, doesSupportMarkdown),
+                        textEdit: TextEdit.replace(range, tag.name),
+                        insertTextFormat: InsertTextFormat.PlainText
+                    });
+                });
+            });
+            return result;
+        }
+        function getLineIndent(offset) {
+            let start = offset;
+            while (start > 0) {
+                const ch = text.charAt(start - 1);
+                if ("\n\r".indexOf(ch) >= 0) {
+                    return text.substring(start, offset);
+                }
+                if (!isWhiteSpace(ch)) {
+                    return null;
+                }
+                start--;
+            }
+            return text.substring(0, offset);
+        }
+        function collectCloseTagSuggestions(afterOpenBracket, inOpenTag, tagNameEnd = offset) {
+            const range = getReplaceRange(afterOpenBracket, tagNameEnd);
+            const closeTag = isFollowedBy(text, tagNameEnd, ScannerState.WithinEndTag, TokenType.EndTagClose) ? '' : '>';
+            let curr = node;
+            if (inOpenTag) {
+                curr = curr.parent; // don't suggest the own tag, it's not yet open
+            }
+            while (curr) {
+                const tag = curr.tag;
+                if (tag && (!curr.closed || curr.endTagStart && (curr.endTagStart > offset))) {
+                    const item = {
+                        label: '/' + tag,
+                        kind: CompletionItemKind.Property,
+                        filterText: '/' + tag,
+                        textEdit: TextEdit.replace(range, '/' + tag + closeTag),
+                        insertTextFormat: InsertTextFormat.PlainText
+                    };
+                    const startIndent = getLineIndent(curr.start);
+                    const endIndent = getLineIndent(afterOpenBracket - 1);
+                    if (startIndent !== null && endIndent !== null && startIndent !== endIndent) {
+                        const insertText = startIndent + '</' + tag + closeTag;
+                        item.textEdit = TextEdit.replace(getReplaceRange(afterOpenBracket - 1 - endIndent.length), insertText);
+                        item.filterText = endIndent + '</' + tag;
+                    }
+                    result.items.push(item);
+                    return result;
+                }
+                curr = curr.parent;
+            }
+            if (inOpenTag) {
+                return result;
+            }
+            dataProviders.forEach(provider => {
+                provider.provideTags().forEach(tag => {
+                    result.items.push({
+                        label: '/' + tag.name,
+                        kind: CompletionItemKind.Property,
+                        documentation: generateDocumentation(tag, undefined, doesSupportMarkdown),
+                        filterText: '/' + tag.name + closeTag,
+                        textEdit: TextEdit.replace(range, '/' + tag.name + closeTag),
+                        insertTextFormat: InsertTextFormat.PlainText
+                    });
+                });
+            });
+            return result;
+        }
+        const collectAutoCloseTagSuggestion = (tagCloseEnd, tag) => {
+            if (settings && settings.hideAutoCompleteProposals) {
+                return result;
+            }
+            voidElements ?? (voidElements = this.dataManager.getVoidElements(dataProviders));
+            if (!this.dataManager.isVoidElement(tag, voidElements)) {
+                const pos = document.positionAt(tagCloseEnd);
+                result.items.push({
+                    label: '</' + tag + '>',
+                    kind: CompletionItemKind.Property,
+                    filterText: '</' + tag + '>',
+                    textEdit: TextEdit.insert(pos, '$0</' + tag + '>'),
+                    insertTextFormat: InsertTextFormat.Snippet
+                });
+            }
+            return result;
+        };
+        function collectTagSuggestions(tagStart, tagEnd) {
+            collectOpenTagSuggestions(tagStart, tagEnd);
+            collectCloseTagSuggestions(tagStart, true, tagEnd);
+            return result;
+        }
+        function getExistingAttributes() {
+            const existingAttributes = Object.create(null);
+            node.attributeNames.forEach(attribute => {
+                existingAttributes[attribute] = true;
+            });
+            return existingAttributes;
+        }
+        function collectAttributeNameSuggestions(nameStart, nameEnd = offset) {
+            let replaceEnd = offset;
+            while (replaceEnd < nameEnd && text[replaceEnd] !== '<') { // < is a valid attribute name character, but we rather assume the attribute name ends. See #23236.
+                replaceEnd++;
+            }
+            const currentAttribute = text.substring(nameStart, nameEnd);
+            const range = getReplaceRange(nameStart, replaceEnd);
+            let value = '';
+            if (!isFollowedBy(text, nameEnd, ScannerState.AfterAttributeName, TokenType.DelimiterAssign)) {
+                const defaultValue = settings?.attributeDefaultValue ?? 'doublequotes';
+                if (defaultValue === 'empty') {
+                    value = '=$1';
+                }
+                else if (defaultValue === 'singlequotes') {
+                    value = '=\'$1\'';
+                }
+                else {
+                    value = '="$1"';
+                }
+            }
+            const seenAttributes = getExistingAttributes();
+            // include current typing attribute
+            seenAttributes[currentAttribute] = false;
+            dataProviders.forEach(provider => {
+                provider.provideAttributes(currentTag).forEach(attr => {
+                    if (seenAttributes[attr.name]) {
+                        return;
+                    }
+                    seenAttributes[attr.name] = true;
+                    let codeSnippet = attr.name;
+                    let command;
+                    if (attr.valueSet !== 'v' && value.length) {
+                        codeSnippet = codeSnippet + value;
+                        if (attr.valueSet || attr.name === 'style') {
+                            command = {
+                                title: 'Suggest',
+                                command: 'editor.action.triggerSuggest'
+                            };
+                        }
+                    }
+                    result.items.push({
+                        label: attr.name,
+                        kind: attr.valueSet === 'handler' ? CompletionItemKind.Function : CompletionItemKind.Value,
+                        documentation: generateDocumentation(attr, undefined, doesSupportMarkdown),
+                        textEdit: TextEdit.replace(range, codeSnippet),
+                        insertTextFormat: InsertTextFormat.Snippet,
+                        command
+                    });
+                });
+            });
+            collectDataAttributesSuggestions(range, seenAttributes);
+            return result;
+        }
+        function collectDataAttributesSuggestions(range, seenAttributes) {
+            const dataAttr = 'data-';
+            const dataAttributes = {};
+            dataAttributes[dataAttr] = `${dataAttr}$1="$2"`;
+            function addNodeDataAttributes(node) {
+                node.attributeNames.forEach(attr => {
+                    if (startsWith(attr, dataAttr) && !dataAttributes[attr] && !seenAttributes[attr]) {
+                        dataAttributes[attr] = attr + '="$1"';
+                    }
+                });
+                node.children.forEach(child => addNodeDataAttributes(child));
+            }
+            if (htmlDocument) {
+                htmlDocument.roots.forEach(root => addNodeDataAttributes(root));
+            }
+            Object.keys(dataAttributes).forEach(attr => result.items.push({
+                label: attr,
+                kind: CompletionItemKind.Value,
+                textEdit: TextEdit.replace(range, dataAttributes[attr]),
+                insertTextFormat: InsertTextFormat.Snippet
+            }));
+        }
+        function collectAttributeValueSuggestions(valueStart, valueEnd = offset) {
+            let range;
+            let addQuotes;
+            let valuePrefix;
+            if (offset > valueStart && offset <= valueEnd && isQuote(text[valueStart])) {
+                // inside quoted attribute
+                const valueContentStart = valueStart + 1;
+                let valueContentEnd = valueEnd;
+                // valueEnd points to the char after quote, which encloses the replace range
+                if (valueEnd > valueStart && text[valueEnd - 1] === text[valueStart]) {
+                    valueContentEnd--;
+                }
+                const wsBefore = getWordStart(text, offset, valueContentStart);
+                const wsAfter = getWordEnd(text, offset, valueContentEnd);
+                range = getReplaceRange(wsBefore, wsAfter);
+                valuePrefix = offset >= valueContentStart && offset <= valueContentEnd ? text.substring(valueContentStart, offset) : '';
+                addQuotes = false;
+            }
+            else {
+                range = getReplaceRange(valueStart, valueEnd);
+                valuePrefix = text.substring(valueStart, offset);
+                addQuotes = true;
+            }
+            if (completionParticipants.length > 0) {
+                const tag = currentTag.toLowerCase();
+                const attribute = currentAttributeName.toLowerCase();
+                const fullRange = getReplaceRange(valueStart, valueEnd);
+                for (const participant of completionParticipants) {
+                    if (participant.onHtmlAttributeValue) {
+                        participant.onHtmlAttributeValue({ document, position, tag, attribute, value: valuePrefix, range: fullRange });
+                    }
+                }
+            }
+            dataProviders.forEach(provider => {
+                provider.provideValues(currentTag, currentAttributeName).forEach(value => {
+                    const insertText = addQuotes ? '"' + value.name + '"' : value.name;
+                    result.items.push({
+                        label: value.name,
+                        filterText: insertText,
+                        kind: CompletionItemKind.Unit,
+                        documentation: generateDocumentation(value, undefined, doesSupportMarkdown),
+                        textEdit: TextEdit.replace(range, insertText),
+                        insertTextFormat: InsertTextFormat.PlainText
+                    });
+                });
+            });
+            collectCharacterEntityProposals();
+            return result;
+        }
+        function scanNextForEndPos(nextToken) {
+            if (offset === scanner.getTokenEnd()) {
+                token = scanner.scan();
+                if (token === nextToken && scanner.getTokenOffset() === offset) {
+                    return scanner.getTokenEnd();
+                }
+            }
+            return offset;
+        }
+        function collectInsideContent() {
+            for (const participant of completionParticipants) {
+                if (participant.onHtmlContent) {
+                    participant.onHtmlContent({ document, position });
+                }
+            }
+            return collectCharacterEntityProposals();
+        }
+        function collectCharacterEntityProposals() {
+            // character entities
+            let k = offset - 1;
+            let characterStart = position.character;
+            while (k >= 0 && isLetterOrDigit(text, k)) {
+                k--;
+                characterStart--;
+            }
+            if (k >= 0 && text[k] === '&') {
+                const range = Range.create(Position.create(position.line, characterStart - 1), position);
+                for (const entity in entities) {
+                    if (endsWith(entity, ';')) {
+                        const label = '&' + entity;
+                        result.items.push({
+                            label,
+                            kind: CompletionItemKind.Keyword,
+                            documentation: l10n.t('Character entity representing \'{0}\'', entities[entity]),
+                            textEdit: TextEdit.replace(range, label),
+                            insertTextFormat: InsertTextFormat.PlainText
+                        });
+                    }
+                }
+            }
+            return result;
+        }
+        function suggestDoctype(replaceStart, replaceEnd) {
+            const range = getReplaceRange(replaceStart, replaceEnd);
+            result.items.push({
+                label: '!DOCTYPE',
+                kind: CompletionItemKind.Property,
+                documentation: 'A preamble for an HTML document.',
+                textEdit: TextEdit.replace(range, '!DOCTYPE html>'),
+                insertTextFormat: InsertTextFormat.PlainText
+            });
+        }
+        let token = scanner.scan();
+        while (token !== TokenType.EOS && scanner.getTokenOffset() <= offset) {
+            switch (token) {
+                case TokenType.StartTagOpen:
+                    if (scanner.getTokenEnd() === offset) {
+                        const endPos = scanNextForEndPos(TokenType.StartTag);
+                        if (position.line === 0) {
+                            suggestDoctype(offset, endPos);
+                        }
+                        return collectTagSuggestions(offset, endPos);
+                    }
+                    break;
+                case TokenType.StartTag:
+                    if (scanner.getTokenOffset() <= offset && offset <= scanner.getTokenEnd()) {
+                        return collectOpenTagSuggestions(scanner.getTokenOffset(), scanner.getTokenEnd());
+                    }
+                    currentTag = scanner.getTokenText();
+                    break;
+                case TokenType.AttributeName:
+                    if (scanner.getTokenOffset() <= offset && offset <= scanner.getTokenEnd()) {
+                        return collectAttributeNameSuggestions(scanner.getTokenOffset(), scanner.getTokenEnd());
+                    }
+                    currentAttributeName = scanner.getTokenText();
+                    break;
+                case TokenType.DelimiterAssign:
+                    if (scanner.getTokenEnd() === offset) {
+                        const endPos = scanNextForEndPos(TokenType.AttributeValue);
+                        return collectAttributeValueSuggestions(offset, endPos);
+                    }
+                    break;
+                case TokenType.AttributeValue:
+                    if (scanner.getTokenOffset() <= offset && offset <= scanner.getTokenEnd()) {
+                        return collectAttributeValueSuggestions(scanner.getTokenOffset(), scanner.getTokenEnd());
+                    }
+                    break;
+                case TokenType.Whitespace:
+                    if (offset <= scanner.getTokenEnd()) {
+                        switch (scanner.getScannerState()) {
+                            case ScannerState.AfterOpeningStartTag:
+                                const startPos = scanner.getTokenOffset();
+                                const endTagPos = scanNextForEndPos(TokenType.StartTag);
+                                return collectTagSuggestions(startPos, endTagPos);
+                            case ScannerState.WithinTag:
+                            case ScannerState.AfterAttributeName:
+                                return collectAttributeNameSuggestions(scanner.getTokenEnd());
+                            case ScannerState.BeforeAttributeValue:
+                                return collectAttributeValueSuggestions(scanner.getTokenEnd());
+                            case ScannerState.AfterOpeningEndTag:
+                                return collectCloseTagSuggestions(scanner.getTokenOffset() - 1, false);
+                            case ScannerState.WithinContent:
+                                return collectInsideContent();
+                        }
+                    }
+                    break;
+                case TokenType.EndTagOpen:
+                    if (offset <= scanner.getTokenEnd()) {
+                        const afterOpenBracket = scanner.getTokenOffset() + 1;
+                        const endOffset = scanNextForEndPos(TokenType.EndTag);
+                        return collectCloseTagSuggestions(afterOpenBracket, false, endOffset);
+                    }
+                    break;
+                case TokenType.EndTag:
+                    if (offset <= scanner.getTokenEnd()) {
+                        let start = scanner.getTokenOffset() - 1;
+                        while (start >= 0) {
+                            const ch = text.charAt(start);
+                            if (ch === '/') {
+                                return collectCloseTagSuggestions(start, false, scanner.getTokenEnd());
+                            }
+                            else if (!isWhiteSpace(ch)) {
+                                break;
+                            }
+                            start--;
+                        }
+                    }
+                    break;
+                case TokenType.StartTagClose:
+                    if (offset <= scanner.getTokenEnd()) {
+                        if (currentTag) {
+                            return collectAutoCloseTagSuggestion(scanner.getTokenEnd(), currentTag);
+                        }
+                    }
+                    break;
+                case TokenType.Content:
+                    if (offset <= scanner.getTokenEnd()) {
+                        return collectInsideContent();
+                    }
+                    break;
+                default:
+                    if (offset <= scanner.getTokenEnd()) {
+                        return result;
+                    }
+                    break;
+            }
+            token = scanner.scan();
+        }
+        return result;
+    }
+    doQuoteComplete(document, position, htmlDocument, settings) {
+        const offset = document.offsetAt(position);
+        if (offset <= 0) {
+            return null;
+        }
+        const defaultValue = settings?.attributeDefaultValue ?? 'doublequotes';
+        if (defaultValue === 'empty') {
+            return null;
+        }
+        const char = document.getText().charAt(offset - 1);
+        if (char !== '=') {
+            return null;
+        }
+        const value = defaultValue === 'doublequotes' ? '"$1"' : '\'$1\'';
+        const node = htmlDocument.findNodeBefore(offset);
+        if (node && node.attributes && node.start < offset && (!node.endTagStart || node.endTagStart > offset)) {
+            const scanner = createScanner(document.getText(), node.start);
+            let token = scanner.scan();
+            while (token !== TokenType.EOS && scanner.getTokenEnd() <= offset) {
+                if (token === TokenType.AttributeName && scanner.getTokenEnd() === offset - 1) {
+                    // Ensure the token is a valid standalone attribute name
+                    token = scanner.scan(); // this should be the = just written
+                    if (token !== TokenType.DelimiterAssign) {
+                        return null;
+                    }
+                    token = scanner.scan();
+                    // Any non-attribute valid tag
+                    if (token === TokenType.Unknown || token === TokenType.AttributeValue) {
+                        return null;
+                    }
+                    return value;
+                }
+                token = scanner.scan();
+            }
+        }
+        return null;
+    }
+    doTagComplete(document, position, htmlDocument) {
+        const offset = document.offsetAt(position);
+        if (offset <= 0) {
+            return null;
+        }
+        const char = document.getText().charAt(offset - 1);
+        if (char === '>') {
+            const node = htmlDocument.findNodeBefore(offset);
+            if (node && node.tag && node.start < offset && (!node.endTagStart || node.endTagStart > offset)) {
+                const voidElements = this.dataManager.getVoidElements(document.languageId);
+                if (!this.dataManager.isVoidElement(node.tag, voidElements)) {
+                    const scanner = createScanner(document.getText(), node.start);
+                    let token = scanner.scan();
+                    while (token !== TokenType.EOS && scanner.getTokenEnd() <= offset) {
+                        if (token === TokenType.StartTagClose && scanner.getTokenEnd() === offset) {
+                            return `$0</${node.tag}>`;
+                        }
+                        token = scanner.scan();
+                    }
+                }
+            }
+        }
+        else if (char === '/') {
+            let node = htmlDocument.findNodeBefore(offset);
+            while (node && node.closed && !(node.endTagStart && (node.endTagStart > offset))) {
+                node = node.parent;
+            }
+            if (node && node.tag) {
+                const scanner = createScanner(document.getText(), node.start);
+                let token = scanner.scan();
+                while (token !== TokenType.EOS && scanner.getTokenEnd() <= offset) {
+                    if (token === TokenType.EndTagOpen && scanner.getTokenEnd() === offset) {
+                        if (document.getText().charAt(offset) !== '>') {
+                            return `${node.tag}>`;
+                        }
+                        else {
+                            return node.tag;
+                        }
+                    }
+                    token = scanner.scan();
+                }
+            }
+        }
+        return null;
+    }
+    convertCompletionList(list) {
+        if (!this.doesSupportMarkdown()) {
+            list.items.forEach(item => {
+                if (item.documentation && typeof item.documentation !== 'string') {
+                    item.documentation = {
+                        kind: 'plaintext',
+                        value: item.documentation.value
+                    };
+                }
+            });
+        }
+        return list;
+    }
+    doesSupportMarkdown() {
+        if (!isDefined(this.supportsMarkdown)) {
+            if (!isDefined(this.lsOptions.clientCapabilities)) {
+                this.supportsMarkdown = true;
+                return this.supportsMarkdown;
+            }
+            const documentationFormat = this.lsOptions.clientCapabilities.textDocument?.completion?.completionItem?.documentationFormat;
+            this.supportsMarkdown = Array.isArray(documentationFormat) && documentationFormat.indexOf(MarkupKind.Markdown) !== -1;
+        }
+        return this.supportsMarkdown;
+    }
+}
+function isQuote(s) {
+    return /^["']*$/.test(s);
+}
+function isWhiteSpace(s) {
+    return /^\s*$/.test(s);
+}
+function isFollowedBy(s, offset, intialState, expectedToken) {
+    const scanner = createScanner(s, offset, intialState);
+    let token = scanner.scan();
+    while (token === TokenType.Whitespace) {
+        token = scanner.scan();
+    }
+    return token === expectedToken;
+}
+function getWordStart(s, offset, limit) {
+    while (offset > limit && !isWhiteSpace(s[offset - 1])) {
+        offset--;
+    }
+    return offset;
+}
+function getWordEnd(s, offset, limit) {
+    while (offset < limit && !isWhiteSpace(s[offset])) {
+        offset++;
+    }
+    return offset;
+}

Java开发环境安装/eclipse-jee-2024-06-R-win32-x86_64/eclipse/plugins/org.eclipse.wildwebdeveloper_1.2.2.202405280856/node_modules/volar-service-html/node_modules/vscode-html-languageservice/lib/esm/services/htmlFolding.js

@@ -1,3 +1,174 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:66d44c7def00f368ba2de426a8645867e58d6d67ba42ca68508773543131de10
-size 7231
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import { TokenType, FoldingRangeKind } from '../htmlLanguageTypes';
+import { createScanner } from '../parser/htmlScanner';
+export class HTMLFolding {
+    constructor(dataManager) {
+        this.dataManager = dataManager;
+    }
+    limitRanges(ranges, rangeLimit) {
+        ranges = ranges.sort((r1, r2) => {
+            let diff = r1.startLine - r2.startLine;
+            if (diff === 0) {
+                diff = r1.endLine - r2.endLine;
+            }
+            return diff;
+        });
+        // compute each range's nesting level in 'nestingLevels'.
+        // count the number of ranges for each level in 'nestingLevelCounts'
+        let top = void 0;
+        const previous = [];
+        const nestingLevels = [];
+        const nestingLevelCounts = [];
+        const setNestingLevel = (index, level) => {
+            nestingLevels[index] = level;
+            if (level < 30) {
+                nestingLevelCounts[level] = (nestingLevelCounts[level] || 0) + 1;
+            }
+        };
+        // compute nesting levels and sanitize
+        for (let i = 0; i < ranges.length; i++) {
+            const entry = ranges[i];
+            if (!top) {
+                top = entry;
+                setNestingLevel(i, 0);
+            }
+            else {
+                if (entry.startLine > top.startLine) {
+                    if (entry.endLine <= top.endLine) {
+                        previous.push(top);
+                        top = entry;
+                        setNestingLevel(i, previous.length);
+                    }
+                    else if (entry.startLine > top.endLine) {
+                        do {
+                            top = previous.pop();
+                        } while (top && entry.startLine > top.endLine);
+                        if (top) {
+                            previous.push(top);
+                        }
+                        top = entry;
+                        setNestingLevel(i, previous.length);
+                    }
+                }
+            }
+        }
+        let entries = 0;
+        let maxLevel = 0;
+        for (let i = 0; i < nestingLevelCounts.length; i++) {
+            const n = nestingLevelCounts[i];
+            if (n) {
+                if (n + entries > rangeLimit) {
+                    maxLevel = i;
+                    break;
+                }
+                entries += n;
+            }
+        }
+        const result = [];
+        for (let i = 0; i < ranges.length; i++) {
+            const level = nestingLevels[i];
+            if (typeof level === 'number') {
+                if (level < maxLevel || (level === maxLevel && entries++ < rangeLimit)) {
+                    result.push(ranges[i]);
+                }
+            }
+        }
+        return result;
+    }
+    getFoldingRanges(document, context) {
+        const scanner = createScanner(document.getText());
+        let token = scanner.scan();
+        const ranges = [];
+        const stack = [];
+        let lastTagName = null;
+        let prevStart = -1;
+        let voidElements;
+        function addRange(range) {
+            ranges.push(range);
+            prevStart = range.startLine;
+        }
+        while (token !== TokenType.EOS) {
+            switch (token) {
+                case TokenType.StartTag: {
+                    const tagName = scanner.getTokenText();
+                    const startLine = document.positionAt(scanner.getTokenOffset()).line;
+                    stack.push({ startLine, tagName });
+                    lastTagName = tagName;
+                    break;
+                }
+                case TokenType.EndTag: {
+                    lastTagName = scanner.getTokenText();
+                    break;
+                }
+                case TokenType.StartTagClose:
+                    if (!lastTagName) {
+                        break;
+                    }
+                    voidElements ?? (voidElements = this.dataManager.getVoidElements(document.languageId));
+                    if (!this.dataManager.isVoidElement(lastTagName, voidElements)) {
+                        break;
+                    }
+                // fallthrough
+                case TokenType.EndTagClose:
+                case TokenType.StartTagSelfClose: {
+                    let i = stack.length - 1;
+                    while (i >= 0 && stack[i].tagName !== lastTagName) {
+                        i--;
+                    }
+                    if (i >= 0) {
+                        const stackElement = stack[i];
+                        stack.length = i;
+                        const line = document.positionAt(scanner.getTokenOffset()).line;
+                        const startLine = stackElement.startLine;
+                        const endLine = line - 1;
+                        if (endLine > startLine && prevStart !== startLine) {
+                            addRange({ startLine, endLine });
+                        }
+                    }
+                    break;
+                }
+                case TokenType.Comment: {
+                    let startLine = document.positionAt(scanner.getTokenOffset()).line;
+                    const text = scanner.getTokenText();
+                    const m = text.match(/^\s*#(region\b)|(endregion\b)/);
+                    if (m) {
+                        if (m[1]) { // start pattern match
+                            stack.push({ startLine, tagName: '' }); // empty tagName marks region
+                        }
+                        else {
+                            let i = stack.length - 1;
+                            while (i >= 0 && stack[i].tagName.length) {
+                                i--;
+                            }
+                            if (i >= 0) {
+                                const stackElement = stack[i];
+                                stack.length = i;
+                                const endLine = startLine;
+                                startLine = stackElement.startLine;
+                                if (endLine > startLine && prevStart !== startLine) {
+                                    addRange({ startLine, endLine, kind: FoldingRangeKind.Region });
+                                }
+                            }
+                        }
+                    }
+                    else {
+                        const endLine = document.positionAt(scanner.getTokenOffset() + scanner.getTokenLength()).line;
+                        if (startLine < endLine) {
+                            addRange({ startLine, endLine, kind: FoldingRangeKind.Comment });
+                        }
+                    }
+                    break;
+                }
+            }
+            token = scanner.scan();
+        }
+        const rangeLimit = context && context.rangeLimit || Number.MAX_VALUE;
+        if (ranges.length > rangeLimit) {
+            return this.limitRanges(ranges, rangeLimit);
+        }
+        return ranges;
+    }
+}

Java开发环境安装/eclipse-jee-2024-06-R-win32-x86_64/eclipse/plugins/org.eclipse.wildwebdeveloper_1.2.2.202405280856/node_modules/volar-service-html/node_modules/vscode-html-languageservice/lib/esm/services/htmlFormatter.js

@@ -1,3 +1,149 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:6ebbd639e5c49cb70ac57b9634ed91673753d3b3e3959606f788b3bf27b2763b
-size 6105
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import { Range, Position } from '../htmlLanguageTypes';
+import { html_beautify } from '../beautify/beautify-html';
+import { repeat } from '../utils/strings';
+export function format(document, range, options) {
+    let value = document.getText();
+    let includesEnd = true;
+    let initialIndentLevel = 0;
+    const tabSize = options.tabSize || 4;
+    if (range) {
+        let startOffset = document.offsetAt(range.start);
+        // include all leading whitespace iff at the beginning of the line
+        let extendedStart = startOffset;
+        while (extendedStart > 0 && isWhitespace(value, extendedStart - 1)) {
+            extendedStart--;
+        }
+        if (extendedStart === 0 || isEOL(value, extendedStart - 1)) {
+            startOffset = extendedStart;
+        }
+        else {
+            // else keep at least one whitespace
+            if (extendedStart < startOffset) {
+                startOffset = extendedStart + 1;
+            }
+        }
+        // include all following whitespace until the end of the line
+        let endOffset = document.offsetAt(range.end);
+        let extendedEnd = endOffset;
+        while (extendedEnd < value.length && isWhitespace(value, extendedEnd)) {
+            extendedEnd++;
+        }
+        if (extendedEnd === value.length || isEOL(value, extendedEnd)) {
+            endOffset = extendedEnd;
+        }
+        range = Range.create(document.positionAt(startOffset), document.positionAt(endOffset));
+        // Do not modify if substring starts in inside an element
+        // Ending inside an element is fine as it doesn't cause formatting errors
+        const firstHalf = value.substring(0, startOffset);
+        if (new RegExp(/.*[<][^>]*$/).test(firstHalf)) {
+            //return without modification
+            value = value.substring(startOffset, endOffset);
+            return [{
+                    range: range,
+                    newText: value
+                }];
+        }
+        includesEnd = endOffset === value.length;
+        value = value.substring(startOffset, endOffset);
+        if (startOffset !== 0) {
+            const startOfLineOffset = document.offsetAt(Position.create(range.start.line, 0));
+            initialIndentLevel = computeIndentLevel(document.getText(), startOfLineOffset, options);
+        }
+    }
+    else {
+        range = Range.create(Position.create(0, 0), document.positionAt(value.length));
+    }
+    const htmlOptions = {
+        indent_size: tabSize,
+        indent_char: options.insertSpaces ? ' ' : '\t',
+        indent_empty_lines: getFormatOption(options, 'indentEmptyLines', false),
+        wrap_line_length: getFormatOption(options, 'wrapLineLength', 120),
+        unformatted: getTagsFormatOption(options, 'unformatted', void 0),
+        content_unformatted: getTagsFormatOption(options, 'contentUnformatted', void 0),
+        indent_inner_html: getFormatOption(options, 'indentInnerHtml', false),
+        preserve_newlines: getFormatOption(options, 'preserveNewLines', true),
+        max_preserve_newlines: getFormatOption(options, 'maxPreserveNewLines', 32786),
+        indent_handlebars: getFormatOption(options, 'indentHandlebars', false),
+        end_with_newline: includesEnd && getFormatOption(options, 'endWithNewline', false),
+        extra_liners: getTagsFormatOption(options, 'extraLiners', void 0),
+        wrap_attributes: getFormatOption(options, 'wrapAttributes', 'auto'),
+        wrap_attributes_indent_size: getFormatOption(options, 'wrapAttributesIndentSize', void 0),
+        eol: '\n',
+        indent_scripts: getFormatOption(options, 'indentScripts', 'normal'),
+        templating: getTemplatingFormatOption(options, 'all'),
+        unformatted_content_delimiter: getFormatOption(options, 'unformattedContentDelimiter', ''),
+    };
+    let result = html_beautify(trimLeft(value), htmlOptions);
+    if (initialIndentLevel > 0) {
+        const indent = options.insertSpaces ? repeat(' ', tabSize * initialIndentLevel) : repeat('\t', initialIndentLevel);
+        result = result.split('\n').join('\n' + indent);
+        if (range.start.character === 0) {
+            result = indent + result; // keep the indent
+        }
+    }
+    return [{
+            range: range,
+            newText: result
+        }];
+}
+function trimLeft(str) {
+    return str.replace(/^\s+/, '');
+}
+function getFormatOption(options, key, dflt) {
+    if (options && options.hasOwnProperty(key)) {
+        const value = options[key];
+        if (value !== null) {
+            return value;
+        }
+    }
+    return dflt;
+}
+function getTagsFormatOption(options, key, dflt) {
+    const list = getFormatOption(options, key, null);
+    if (typeof list === 'string') {
+        if (list.length > 0) {
+            return list.split(',').map(t => t.trim().toLowerCase());
+        }
+        return [];
+    }
+    return dflt;
+}
+function getTemplatingFormatOption(options, dflt) {
+    const value = getFormatOption(options, 'templating', dflt);
+    if (value === true) {
+        return ['auto'];
+    }
+    if (value === false || value === dflt || Array.isArray(value) === false) {
+        return ['none'];
+    }
+    return value;
+}
+function computeIndentLevel(content, offset, options) {
+    let i = offset;
+    let nChars = 0;
+    const tabSize = options.tabSize || 4;
+    while (i < content.length) {
+        const ch = content.charAt(i);
+        if (ch === ' ') {
+            nChars++;
+        }
+        else if (ch === '\t') {
+            nChars += tabSize;
+        }
+        else {
+            break;
+        }
+        i++;
+    }
+    return Math.floor(nChars / tabSize);
+}
+function isEOL(text, offset) {
+    return '\r\n'.indexOf(text.charAt(offset)) !== -1;
+}
+function isWhitespace(text, offset) {
+    return ' \t'.indexOf(text.charAt(offset)) !== -1;
+}

Java开发环境安装/eclipse-jee-2024-06-R-win32-x86_64/eclipse/plugins/org.eclipse.wildwebdeveloper_1.2.2.202405280856/node_modules/volar-service-html/node_modules/vscode-html-languageservice/lib/esm/services/htmlHighlighting.js

@@ -1,3 +1,42 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:1dfc563fcba9e443d822e0447e881e1b2e564e8563380091f11d7078975b4442
-size 2023
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import { createScanner } from '../parser/htmlScanner';
+import { TokenType, DocumentHighlightKind } from '../htmlLanguageTypes';
+export function findDocumentHighlights(document, position, htmlDocument) {
+    const offset = document.offsetAt(position);
+    const node = htmlDocument.findNodeAt(offset);
+    if (!node.tag) {
+        return [];
+    }
+    const result = [];
+    const startTagRange = getTagNameRange(TokenType.StartTag, document, node.start);
+    const endTagRange = typeof node.endTagStart === 'number' && getTagNameRange(TokenType.EndTag, document, node.endTagStart);
+    if (startTagRange && covers(startTagRange, position) || endTagRange && covers(endTagRange, position)) {
+        if (startTagRange) {
+            result.push({ kind: DocumentHighlightKind.Read, range: startTagRange });
+        }
+        if (endTagRange) {
+            result.push({ kind: DocumentHighlightKind.Read, range: endTagRange });
+        }
+    }
+    return result;
+}
+function isBeforeOrEqual(pos1, pos2) {
+    return pos1.line < pos2.line || (pos1.line === pos2.line && pos1.character <= pos2.character);
+}
+function covers(range, position) {
+    return isBeforeOrEqual(range.start, position) && isBeforeOrEqual(position, range.end);
+}
+function getTagNameRange(tokenType, document, startOffset) {
+    const scanner = createScanner(document.getText(), startOffset);
+    let token = scanner.scan();
+    while (token !== TokenType.EOS && token !== tokenType) {
+        token = scanner.scan();
+    }
+    if (token !== TokenType.EOS) {
+        return { start: document.positionAt(scanner.getTokenOffset()), end: document.positionAt(scanner.getTokenEnd()) };
+    }
+    return null;
+}

Java开发环境安装/eclipse-jee-2024-06-R-win32-x86_64/eclipse/plugins/org.eclipse.wildwebdeveloper_1.2.2.202405280856/node_modules/volar-service-html/node_modules/vscode-html-languageservice/lib/esm/services/htmlHover.js

@@ -1,3 +1,265 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:a83fbfb9de32079664bf695dbfe549e5c7445683e861ac0476f4006d1eeb58bb
-size 10961
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import { createScanner } from '../parser/htmlScanner';
+import { TokenType, Range, Position, MarkupKind } from '../htmlLanguageTypes';
+import { isDefined } from '../utils/object';
+import { generateDocumentation } from '../languageFacts/dataProvider';
+import { entities } from '../parser/htmlEntities';
+import { isLetterOrDigit } from '../utils/strings';
+import * as l10n from '@vscode/l10n';
+export class HTMLHover {
+    constructor(lsOptions, dataManager) {
+        this.lsOptions = lsOptions;
+        this.dataManager = dataManager;
+    }
+    doHover(document, position, htmlDocument, options) {
+        const convertContents = this.convertContents.bind(this);
+        const doesSupportMarkdown = this.doesSupportMarkdown();
+        const offset = document.offsetAt(position);
+        const node = htmlDocument.findNodeAt(offset);
+        const text = document.getText();
+        if (!node || !node.tag) {
+            return null;
+        }
+        const dataProviders = this.dataManager.getDataProviders().filter(p => p.isApplicable(document.languageId));
+        function getTagHover(currTag, range, open) {
+            for (const provider of dataProviders) {
+                let hover = null;
+                provider.provideTags().forEach(tag => {
+                    if (tag.name.toLowerCase() === currTag.toLowerCase()) {
+                        let markupContent = generateDocumentation(tag, options, doesSupportMarkdown);
+                        if (!markupContent) {
+                            markupContent = {
+                                kind: doesSupportMarkdown ? 'markdown' : 'plaintext',
+                                value: ''
+                            };
+                        }
+                        hover = { contents: markupContent, range };
+                    }
+                });
+                if (hover) {
+                    hover.contents = convertContents(hover.contents);
+                    return hover;
+                }
+            }
+            return null;
+        }
+        function getAttrHover(currTag, currAttr, range) {
+            for (const provider of dataProviders) {
+                let hover = null;
+                provider.provideAttributes(currTag).forEach(attr => {
+                    if (currAttr === attr.name && attr.description) {
+                        const contentsDoc = generateDocumentation(attr, options, doesSupportMarkdown);
+                        if (contentsDoc) {
+                            hover = { contents: contentsDoc, range };
+                        }
+                        else {
+                            hover = null;
+                        }
+                    }
+                });
+                if (hover) {
+                    hover.contents = convertContents(hover.contents);
+                    return hover;
+                }
+            }
+            return null;
+        }
+        function getAttrValueHover(currTag, currAttr, currAttrValue, range) {
+            for (const provider of dataProviders) {
+                let hover = null;
+                provider.provideValues(currTag, currAttr).forEach(attrValue => {
+                    if (currAttrValue === attrValue.name && attrValue.description) {
+                        const contentsDoc = generateDocumentation(attrValue, options, doesSupportMarkdown);
+                        if (contentsDoc) {
+                            hover = { contents: contentsDoc, range };
+                        }
+                        else {
+                            hover = null;
+                        }
+                    }
+                });
+                if (hover) {
+                    hover.contents = convertContents(hover.contents);
+                    return hover;
+                }
+            }
+            return null;
+        }
+        function getEntityHover(text, range) {
+            let currEntity = filterEntity(text);
+            for (const entity in entities) {
+                let hover = null;
+                const label = '&' + entity;
+                if (currEntity === label) {
+                    let code = entities[entity].charCodeAt(0).toString(16).toUpperCase();
+                    let hex = 'U+';
+                    if (code.length < 4) {
+                        const zeroes = 4 - code.length;
+                        let k = 0;
+                        while (k < zeroes) {
+                            hex += '0';
+                            k += 1;
+                        }
+                    }
+                    hex += code;
+                    const contentsDoc = l10n.t('Character entity representing \'{0}\', unicode equivalent \'{1}\'', entities[entity], hex);
+                    if (contentsDoc) {
+                        hover = { contents: contentsDoc, range };
+                    }
+                    else {
+                        hover = null;
+                    }
+                }
+                if (hover) {
+                    hover.contents = convertContents(hover.contents);
+                    return hover;
+                }
+            }
+            return null;
+        }
+        function getTagNameRange(tokenType, startOffset) {
+            const scanner = createScanner(document.getText(), startOffset);
+            let token = scanner.scan();
+            while (token !== TokenType.EOS && (scanner.getTokenEnd() < offset || scanner.getTokenEnd() === offset && token !== tokenType)) {
+                token = scanner.scan();
+            }
+            if (token === tokenType && offset <= scanner.getTokenEnd()) {
+                return { start: document.positionAt(scanner.getTokenOffset()), end: document.positionAt(scanner.getTokenEnd()) };
+            }
+            return null;
+        }
+        function getEntityRange() {
+            let k = offset - 1;
+            let characterStart = position.character;
+            while (k >= 0 && isLetterOrDigit(text, k)) {
+                k--;
+                characterStart--;
+            }
+            let n = k + 1;
+            let characterEnd = characterStart;
+            while (isLetterOrDigit(text, n)) {
+                n++;
+                characterEnd++;
+            }
+            if (k >= 0 && text[k] === '&') {
+                let range = null;
+                if (text[n] === ';') {
+                    range = Range.create(Position.create(position.line, characterStart), Position.create(position.line, characterEnd + 1));
+                }
+                else {
+                    range = Range.create(Position.create(position.line, characterStart), Position.create(position.line, characterEnd));
+                }
+                return range;
+            }
+            return null;
+        }
+        function filterEntity(text) {
+            let k = offset - 1;
+            let newText = '&';
+            while (k >= 0 && isLetterOrDigit(text, k)) {
+                k--;
+            }
+            k = k + 1;
+            while (isLetterOrDigit(text, k)) {
+                newText += text[k];
+                k += 1;
+            }
+            newText += ';';
+            return newText;
+        }
+        if (node.endTagStart && offset >= node.endTagStart) {
+            const tagRange = getTagNameRange(TokenType.EndTag, node.endTagStart);
+            if (tagRange) {
+                return getTagHover(node.tag, tagRange, false);
+            }
+            return null;
+        }
+        const tagRange = getTagNameRange(TokenType.StartTag, node.start);
+        if (tagRange) {
+            return getTagHover(node.tag, tagRange, true);
+        }
+        const attrRange = getTagNameRange(TokenType.AttributeName, node.start);
+        if (attrRange) {
+            const tag = node.tag;
+            const attr = document.getText(attrRange);
+            return getAttrHover(tag, attr, attrRange);
+        }
+        const entityRange = getEntityRange();
+        if (entityRange) {
+            return getEntityHover(text, entityRange);
+        }
+        function scanAttrAndAttrValue(nodeStart, attrValueStart) {
+            const scanner = createScanner(document.getText(), nodeStart);
+            let token = scanner.scan();
+            let prevAttr = undefined;
+            while (token !== TokenType.EOS && (scanner.getTokenEnd() <= attrValueStart)) {
+                token = scanner.scan();
+                if (token === TokenType.AttributeName) {
+                    prevAttr = scanner.getTokenText();
+                }
+            }
+            return prevAttr;
+        }
+        const attrValueRange = getTagNameRange(TokenType.AttributeValue, node.start);
+        if (attrValueRange) {
+            const tag = node.tag;
+            const attrValue = trimQuotes(document.getText(attrValueRange));
+            const matchAttr = scanAttrAndAttrValue(node.start, document.offsetAt(attrValueRange.start));
+            if (matchAttr) {
+                return getAttrValueHover(tag, matchAttr, attrValue, attrValueRange);
+            }
+        }
+        return null;
+    }
+    convertContents(contents) {
+        if (!this.doesSupportMarkdown()) {
+            if (typeof contents === 'string') {
+                return contents;
+            }
+            // MarkupContent
+            else if ('kind' in contents) {
+                return {
+                    kind: 'plaintext',
+                    value: contents.value
+                };
+            }
+            // MarkedString[]
+            else if (Array.isArray(contents)) {
+                contents.map(c => {
+                    return typeof c === 'string' ? c : c.value;
+                });
+            }
+            // MarkedString
+            else {
+                return contents.value;
+            }
+        }
+        return contents;
+    }
+    doesSupportMarkdown() {
+        if (!isDefined(this.supportsMarkdown)) {
+            if (!isDefined(this.lsOptions.clientCapabilities)) {
+                this.supportsMarkdown = true;
+                return this.supportsMarkdown;
+            }
+            const contentFormat = this.lsOptions.clientCapabilities?.textDocument?.hover?.contentFormat;
+            this.supportsMarkdown = Array.isArray(contentFormat) && contentFormat.indexOf(MarkupKind.Markdown) !== -1;
+        }
+        return this.supportsMarkdown;
+    }
+}
+function trimQuotes(s) {
+    if (s.length <= 1) {
+        return s.replace(/['"]/, ''); // CodeQL [SM02383] False positive: The string length is at most one, so we don't need the global flag.
+    }
+    if (s[0] === `'` || s[0] === `"`) {
+        s = s.slice(1);
+    }
+    if (s[s.length - 1] === `'` || s[s.length - 1] === `"`) {
+        s = s.slice(0, -1);
+    }
+    return s;
+}

Java开发环境安装/eclipse-jee-2024-06-R-win32-x86_64/eclipse/plugins/org.eclipse.wildwebdeveloper_1.2.2.202405280856/node_modules/volar-service-html/node_modules/vscode-html-languageservice/lib/esm/services/htmlLinkedEditing.js

@@ -1,3 +1,24 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:be26e8b36ceef3117c3585d4142fbfa96b8107efb1b3d5b2443d06152fb36eb6
-size 1307
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import { Range } from '../htmlLanguageTypes';
+export function findLinkedEditingRanges(document, position, htmlDocument) {
+    const offset = document.offsetAt(position);
+    const node = htmlDocument.findNodeAt(offset);
+    const tagLength = node.tag ? node.tag.length : 0;
+    if (!node.endTagStart) {
+        return null;
+    }
+    if (
+    // Within open tag, compute close tag
+    (node.start + '<'.length <= offset && offset <= node.start + '<'.length + tagLength) ||
+        // Within closing tag, compute open tag
+        node.endTagStart + '</'.length <= offset && offset <= node.endTagStart + '</'.length + tagLength) {
+        return [
+            Range.create(document.positionAt(node.start + '<'.length), document.positionAt(node.start + '<'.length + tagLength)),
+            Range.create(document.positionAt(node.endTagStart + '</'.length), document.positionAt(node.endTagStart + '</'.length + tagLength))
+        ];
+    }
+    return null;
+}

Java开发环境安装/eclipse-jee-2024-06-R-win32-x86_64/eclipse/plugins/org.eclipse.wildwebdeveloper_1.2.2.202405280856/node_modules/volar-service-html/node_modules/vscode-html-languageservice/lib/esm/services/htmlLinks.js

@@ -1,3 +1,157 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:6464a386826b6320495369984cd1dd34ad3d403aa71a6473553bd65659e88ab9
-size 6591
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import { createScanner } from '../parser/htmlScanner';
+import * as strings from '../utils/strings';
+import { URI as Uri } from 'vscode-uri';
+import { TokenType, Range } from '../htmlLanguageTypes';
+function normalizeRef(url) {
+    const first = url[0];
+    const last = url[url.length - 1];
+    if (first === last && (first === '\'' || first === '\"')) {
+        url = url.substring(1, url.length - 1);
+    }
+    return url;
+}
+function validateRef(url, languageId) {
+    if (!url.length) {
+        return false;
+    }
+    if (languageId === 'handlebars' && /{{|}}/.test(url)) {
+        return false;
+    }
+    return /\b(w[\w\d+.-]*:\/\/)?[^\s()<>]+(?:\([\w\d]+\)|([^[:punct:]\s]|\/?))/.test(url);
+}
+function getWorkspaceUrl(documentUri, tokenContent, documentContext, base) {
+    if (/^\s*javascript\:/i.test(tokenContent) || /[\n\r]/.test(tokenContent)) {
+        return undefined;
+    }
+    tokenContent = tokenContent.replace(/^\s*/g, '');
+    const match = tokenContent.match(/^(\w[\w\d+.-]*):/);
+    if (match) {
+        // Absolute link that needs no treatment
+        const schema = match[1].toLowerCase();
+        if (schema === 'http' || schema === 'https' || schema === 'file') {
+            return tokenContent;
+        }
+        return undefined;
+    }
+    if (/^\#/i.test(tokenContent)) {
+        return documentUri + tokenContent;
+    }
+    if (/^\/\//i.test(tokenContent)) {
+        // Absolute link (that does not name the protocol)
+        const pickedScheme = strings.startsWith(documentUri, 'https://') ? 'https' : 'http';
+        return pickedScheme + ':' + tokenContent.replace(/^\s*/g, '');
+    }
+    if (documentContext) {
+        return documentContext.resolveReference(tokenContent, base || documentUri);
+    }
+    return tokenContent;
+}
+function createLink(document, documentContext, attributeValue, startOffset, endOffset, base) {
+    const tokenContent = normalizeRef(attributeValue);
+    if (!validateRef(tokenContent, document.languageId)) {
+        return undefined;
+    }
+    if (tokenContent.length < attributeValue.length) {
+        startOffset++;
+        endOffset--;
+    }
+    const workspaceUrl = getWorkspaceUrl(document.uri, tokenContent, documentContext, base);
+    if (!workspaceUrl) {
+        return undefined;
+    }
+    const target = validateAndCleanURI(workspaceUrl, document);
+    return {
+        range: Range.create(document.positionAt(startOffset), document.positionAt(endOffset)),
+        target
+    };
+}
+const _hash = '#'.charCodeAt(0);
+function validateAndCleanURI(uriStr, document) {
+    try {
+        let uri = Uri.parse(uriStr);
+        if (uri.scheme === 'file' && uri.query) {
+            // see https://github.com/microsoft/vscode/issues/194577 & https://github.com/microsoft/vscode/issues/206238
+            uri = uri.with({ query: null });
+            uriStr = uri.toString(/* skipEncodig*/ true);
+        }
+        if (uri.scheme === 'file' && uri.fragment && !(uriStr.startsWith(document.uri) && uriStr.charCodeAt(document.uri.length) === _hash)) {
+            return uri.with({ fragment: null }).toString(/* skipEncodig*/ true);
+        }
+        return uriStr;
+    }
+    catch (e) {
+        return undefined;
+    }
+}
+export class HTMLDocumentLinks {
+    constructor(dataManager) {
+        this.dataManager = dataManager;
+    }
+    findDocumentLinks(document, documentContext) {
+        const newLinks = [];
+        const scanner = createScanner(document.getText(), 0);
+        let token = scanner.scan();
+        let lastAttributeName = undefined;
+        let lastTagName = undefined;
+        let afterBase = false;
+        let base = void 0;
+        const idLocations = {};
+        while (token !== TokenType.EOS) {
+            switch (token) {
+                case TokenType.StartTag:
+                    lastTagName = scanner.getTokenText().toLowerCase();
+                    if (!base) {
+                        afterBase = lastTagName === 'base';
+                    }
+                    break;
+                case TokenType.AttributeName:
+                    lastAttributeName = scanner.getTokenText().toLowerCase();
+                    break;
+                case TokenType.AttributeValue:
+                    if (lastTagName && lastAttributeName && this.dataManager.isPathAttribute(lastTagName, lastAttributeName)) {
+                        const attributeValue = scanner.getTokenText();
+                        if (!afterBase) { // don't highlight the base link itself
+                            const link = createLink(document, documentContext, attributeValue, scanner.getTokenOffset(), scanner.getTokenEnd(), base);
+                            if (link) {
+                                newLinks.push(link);
+                            }
+                        }
+                        if (afterBase && typeof base === 'undefined') {
+                            base = normalizeRef(attributeValue);
+                            if (base && documentContext) {
+                                base = documentContext.resolveReference(base, document.uri);
+                            }
+                        }
+                        afterBase = false;
+                        lastAttributeName = undefined;
+                    }
+                    else if (lastAttributeName === 'id') {
+                        const id = normalizeRef(scanner.getTokenText());
+                        idLocations[id] = scanner.getTokenOffset();
+                    }
+                    break;
+            }
+            token = scanner.scan();
+        }
+        // change local links with ids to actual positions
+        for (const link of newLinks) {
+            const localWithHash = document.uri + '#';
+            if (link.target && strings.startsWith(link.target, localWithHash)) {
+                const target = link.target.substring(localWithHash.length);
+                const offset = idLocations[target];
+                if (offset !== undefined) {
+                    const pos = document.positionAt(offset);
+                    link.target = `${localWithHash}${pos.line + 1},${pos.character + 1}`;
+                }
+                else {
+                    link.target = document.uri;
+                }
+            }
+        }
+        return newLinks;
+    }
+}

Java开发环境安装/eclipse-jee-2024-06-R-win32-x86_64/eclipse/plugins/org.eclipse.wildwebdeveloper_1.2.2.202405280856/node_modules/volar-service-html/node_modules/vscode-html-languageservice/lib/esm/services/htmlMatchingTagPosition.js

@@ -1,3 +1,25 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:3311998f543d08e853a1c04f994e889ebe1890bb064590ba51c54266bfec4793
-size 1257
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+export function findMatchingTagPosition(document, position, htmlDocument) {
+    const offset = document.offsetAt(position);
+    const node = htmlDocument.findNodeAt(offset);
+    if (!node.tag) {
+        return null;
+    }
+    if (!node.endTagStart) {
+        return null;
+    }
+    // Within open tag, compute close tag
+    if (node.start + '<'.length <= offset && offset <= node.start + '<'.length + node.tag.length) {
+        const mirrorOffset = (offset - '<'.length - node.start) + node.endTagStart + '</'.length;
+        return document.positionAt(mirrorOffset);
+    }
+    // Within closing tag, compute open tag
+    if (node.endTagStart + '</'.length <= offset && offset <= node.endTagStart + '</'.length + node.tag.length) {
+        const mirrorOffset = (offset - '</'.length - node.endTagStart) + node.start + '<'.length;
+        return document.positionAt(mirrorOffset);
+    }
+    return null;
+}

Java开发环境安装/eclipse-jee-2024-06-R-win32-x86_64/eclipse/plugins/org.eclipse.wildwebdeveloper_1.2.2.202405280856/node_modules/volar-service-html/node_modules/vscode-html-languageservice/lib/esm/services/htmlRename.js

@@ -1,3 +1,51 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:ac75b5f6a6102e96745884f4a78af505e13352cb1942039eeb7eea8560538d98
-size 1791
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+export function doRename(document, position, newName, htmlDocument) {
+    const offset = document.offsetAt(position);
+    const node = htmlDocument.findNodeAt(offset);
+    if (!node.tag) {
+        return null;
+    }
+    if (!isWithinTagRange(node, offset, node.tag)) {
+        return null;
+    }
+    const edits = [];
+    const startTagRange = {
+        start: document.positionAt(node.start + '<'.length),
+        end: document.positionAt(node.start + '<'.length + node.tag.length)
+    };
+    edits.push({
+        range: startTagRange,
+        newText: newName
+    });
+    if (node.endTagStart) {
+        const endTagRange = {
+            start: document.positionAt(node.endTagStart + '</'.length),
+            end: document.positionAt(node.endTagStart + '</'.length + node.tag.length)
+        };
+        edits.push({
+            range: endTagRange,
+            newText: newName
+        });
+    }
+    const changes = {
+        [document.uri.toString()]: edits
+    };
+    return {
+        changes
+    };
+}
+function toLocString(p) {
+    return `(${p.line}, ${p.character})`;
+}
+function isWithinTagRange(node, offset, nodeTag) {
+    // Self-closing tag
+    if (node.endTagStart) {
+        if (node.endTagStart + '</'.length <= offset && offset <= node.endTagStart + '</'.length + nodeTag.length) {
+            return true;
+        }
+    }
+    return node.start + '<'.length <= offset && offset <= node.start + '<'.length + nodeTag.length;
+}

Java开发环境安装/eclipse-jee-2024-06-R-win32-x86_64/eclipse/plugins/org.eclipse.wildwebdeveloper_1.2.2.202405280856/node_modules/volar-service-html/node_modules/vscode-html-languageservice/lib/esm/services/htmlSelectionRange.js

@@ -1,3 +1,174 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:81659d3c1df8e4359a34898ca13e848425bf28df61c2743e07c43e13a30aa547
-size 7502
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import { createScanner } from '../parser/htmlScanner';
+import { TokenType, Range, SelectionRange } from '../htmlLanguageTypes';
+export class HTMLSelectionRange {
+    constructor(htmlParser) {
+        this.htmlParser = htmlParser;
+    }
+    getSelectionRanges(document, positions) {
+        const htmlDocument = this.htmlParser.parseDocument(document);
+        return positions.map(p => this.getSelectionRange(p, document, htmlDocument));
+    }
+    getSelectionRange(position, document, htmlDocument) {
+        const applicableRanges = this.getApplicableRanges(document, position, htmlDocument);
+        let prev = undefined;
+        let current = undefined;
+        for (let index = applicableRanges.length - 1; index >= 0; index--) {
+            const range = applicableRanges[index];
+            if (!prev || range[0] !== prev[0] || range[1] !== prev[1]) {
+                current = SelectionRange.create(Range.create(document.positionAt(applicableRanges[index][0]), document.positionAt(applicableRanges[index][1])), current);
+            }
+            prev = range;
+        }
+        if (!current) {
+            current = SelectionRange.create(Range.create(position, position));
+        }
+        return current;
+    }
+    getApplicableRanges(document, position, htmlDoc) {
+        const currOffset = document.offsetAt(position);
+        const currNode = htmlDoc.findNodeAt(currOffset);
+        let result = this.getAllParentTagRanges(currNode);
+        // Self-closing or void elements
+        if (currNode.startTagEnd && !currNode.endTagStart) {
+            // THe rare case of unmatching tag pairs like <div></div1>
+            if (currNode.startTagEnd !== currNode.end) {
+                return [[currNode.start, currNode.end]];
+            }
+            const closeRange = Range.create(document.positionAt(currNode.startTagEnd - 2), document.positionAt(currNode.startTagEnd));
+            const closeText = document.getText(closeRange);
+            // Self-closing element
+            if (closeText === '/>') {
+                result.unshift([currNode.start + 1, currNode.startTagEnd - 2]);
+            }
+            // Void element
+            else {
+                result.unshift([currNode.start + 1, currNode.startTagEnd - 1]);
+            }
+            const attributeLevelRanges = this.getAttributeLevelRanges(document, currNode, currOffset);
+            result = attributeLevelRanges.concat(result);
+            return result;
+        }
+        if (!currNode.startTagEnd || !currNode.endTagStart) {
+            return result;
+        }
+        /**
+         * For html like
+         * `<div class="foo">bar</div>`
+         */
+        result.unshift([currNode.start, currNode.end]);
+        /**
+         * Cursor inside `<div class="foo">`
+         */
+        if (currNode.start < currOffset && currOffset < currNode.startTagEnd) {
+            result.unshift([currNode.start + 1, currNode.startTagEnd - 1]);
+            const attributeLevelRanges = this.getAttributeLevelRanges(document, currNode, currOffset);
+            result = attributeLevelRanges.concat(result);
+            return result;
+        }
+        /**
+         * Cursor inside `bar`
+         */
+        else if (currNode.startTagEnd <= currOffset && currOffset <= currNode.endTagStart) {
+            result.unshift([currNode.startTagEnd, currNode.endTagStart]);
+            return result;
+        }
+        /**
+         * Cursor inside `</div>`
+         */
+        else {
+            // `div` inside `</div>`
+            if (currOffset >= currNode.endTagStart + 2) {
+                result.unshift([currNode.endTagStart + 2, currNode.end - 1]);
+            }
+            return result;
+        }
+    }
+    getAllParentTagRanges(initialNode) {
+        let currNode = initialNode;
+        const result = [];
+        while (currNode.parent) {
+            currNode = currNode.parent;
+            this.getNodeRanges(currNode).forEach(r => result.push(r));
+        }
+        return result;
+    }
+    getNodeRanges(n) {
+        if (n.startTagEnd && n.endTagStart && n.startTagEnd < n.endTagStart) {
+            return [
+                [n.startTagEnd, n.endTagStart],
+                [n.start, n.end]
+            ];
+        }
+        return [
+            [n.start, n.end]
+        ];
+    }
+    ;
+    getAttributeLevelRanges(document, currNode, currOffset) {
+        const currNodeRange = Range.create(document.positionAt(currNode.start), document.positionAt(currNode.end));
+        const currNodeText = document.getText(currNodeRange);
+        const relativeOffset = currOffset - currNode.start;
+        /**
+         * Tag level semantic selection
+         */
+        const scanner = createScanner(currNodeText);
+        let token = scanner.scan();
+        /**
+         * For text like
+         * <div class="foo">bar</div>
+         */
+        const positionOffset = currNode.start;
+        const result = [];
+        let isInsideAttribute = false;
+        let attrStart = -1;
+        while (token !== TokenType.EOS) {
+            switch (token) {
+                case TokenType.AttributeName: {
+                    if (relativeOffset < scanner.getTokenOffset()) {
+                        isInsideAttribute = false;
+                        break;
+                    }
+                    if (relativeOffset <= scanner.getTokenEnd()) {
+                        // `class`
+                        result.unshift([scanner.getTokenOffset(), scanner.getTokenEnd()]);
+                    }
+                    isInsideAttribute = true;
+                    attrStart = scanner.getTokenOffset();
+                    break;
+                }
+                case TokenType.AttributeValue: {
+                    if (!isInsideAttribute) {
+                        break;
+                    }
+                    const valueText = scanner.getTokenText();
+                    if (relativeOffset < scanner.getTokenOffset()) {
+                        // `class="foo"`
+                        result.push([attrStart, scanner.getTokenEnd()]);
+                        break;
+                    }
+                    if (relativeOffset >= scanner.getTokenOffset() && relativeOffset <= scanner.getTokenEnd()) {
+                        // `"foo"`
+                        result.unshift([scanner.getTokenOffset(), scanner.getTokenEnd()]);
+                        // `foo`
+                        if ((valueText[0] === `"` && valueText[valueText.length - 1] === `"`) || (valueText[0] === `'` && valueText[valueText.length - 1] === `'`)) {
+                            if (relativeOffset >= scanner.getTokenOffset() + 1 && relativeOffset <= scanner.getTokenEnd() - 1) {
+                                result.unshift([scanner.getTokenOffset() + 1, scanner.getTokenEnd() - 1]);
+                            }
+                        }
+                        // `class="foo"`
+                        result.push([attrStart, scanner.getTokenEnd()]);
+                    }
+                    break;
+                }
+            }
+            token = scanner.scan();
+        }
+        return result.map(pair => {
+            return [pair[0] + positionOffset, pair[1] + positionOffset];
+        });
+    }
+}

Java开发环境安装/eclipse-jee-2024-06-R-win32-x86_64/eclipse/plugins/org.eclipse.wildwebdeveloper_1.2.2.202405280856/node_modules/volar-service-html/node_modules/vscode-html-languageservice/lib/esm/services/htmlSymbolsProvider.js

@@ -1,3 +1,54 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:f539b2d729b7f61afb8ffeab4d87a2e83e5d78f4bf0248471ee246291f4d60c8
-size 2199
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import { DocumentSymbol, Range, SymbolInformation, SymbolKind } from '../htmlLanguageTypes';
+export function findDocumentSymbols(document, htmlDocument) {
+    const symbols = [];
+    const symbols2 = findDocumentSymbols2(document, htmlDocument);
+    for (const symbol of symbols2) {
+        walk(symbol, undefined);
+    }
+    return symbols;
+    function walk(node, parent) {
+        const symbol = SymbolInformation.create(node.name, node.kind, node.range, document.uri, parent?.name);
+        symbol.containerName ?? (symbol.containerName = '');
+        symbols.push(symbol);
+        if (node.children) {
+            for (const child of node.children) {
+                walk(child, node);
+            }
+        }
+    }
+}
+export function findDocumentSymbols2(document, htmlDocument) {
+    const symbols = [];
+    htmlDocument.roots.forEach(node => {
+        provideFileSymbolsInternal(document, node, symbols);
+    });
+    return symbols;
+}
+function provideFileSymbolsInternal(document, node, symbols) {
+    const name = nodeToName(node);
+    const range = Range.create(document.positionAt(node.start), document.positionAt(node.end));
+    const symbol = DocumentSymbol.create(name, undefined, SymbolKind.Field, range, range);
+    symbols.push(symbol);
+    node.children.forEach(child => {
+        symbol.children ?? (symbol.children = []);
+        provideFileSymbolsInternal(document, child, symbol.children);
+    });
+}
+function nodeToName(node) {
+    let name = node.tag;
+    if (node.attributes) {
+        const id = node.attributes['id'];
+        const classes = node.attributes['class'];
+        if (id) {
+            name += `#${id.replace(/[\"\']/g, '')}`;
+        }
+        if (classes) {
+            name += classes.replace(/[\"\']/g, '').split(/\s+/).map(className => `.${className}`).join('');
+        }
+    }
+    return name || '?';
+}

Java开发环境安装/eclipse-jee-2024-06-R-win32-x86_64/eclipse/plugins/org.eclipse.wildwebdeveloper_1.2.2.202405280856/node_modules/volar-service-html/node_modules/vscode-html-languageservice/lib/esm/services/pathCompletion.js

@@ -1,3 +1,126 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:60c4729e6f62e0324da040c7ab833eb5757f1d2b4de05c473c840e62c2e23f30
-size 5079
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import { CompletionItemKind, TextEdit, Range, Position, FileType } from '../htmlLanguageTypes';
+import { startsWith } from '../utils/strings';
+export class PathCompletionParticipant {
+    constructor(dataManager, readDirectory) {
+        this.dataManager = dataManager;
+        this.readDirectory = readDirectory;
+        this.atributeCompletions = [];
+    }
+    onHtmlAttributeValue(context) {
+        if (this.dataManager.isPathAttribute(context.tag, context.attribute)) {
+            this.atributeCompletions.push(context);
+        }
+    }
+    async computeCompletions(document, documentContext) {
+        const result = { items: [], isIncomplete: false };
+        for (const attributeCompletion of this.atributeCompletions) {
+            const fullValue = stripQuotes(document.getText(attributeCompletion.range));
+            if (isCompletablePath(fullValue)) {
+                if (fullValue === '.' || fullValue === '..') {
+                    result.isIncomplete = true;
+                }
+                else {
+                    const replaceRange = pathToReplaceRange(attributeCompletion.value, fullValue, attributeCompletion.range);
+                    const suggestions = await this.providePathSuggestions(attributeCompletion.value, replaceRange, document, documentContext);
+                    for (const item of suggestions) {
+                        result.items.push(item);
+                    }
+                }
+            }
+        }
+        return result;
+    }
+    async providePathSuggestions(valueBeforeCursor, replaceRange, document, documentContext) {
+        const valueBeforeLastSlash = valueBeforeCursor.substring(0, valueBeforeCursor.lastIndexOf('/') + 1); // keep the last slash
+        let parentDir = documentContext.resolveReference(valueBeforeLastSlash || '.', document.uri);
+        if (parentDir) {
+            try {
+                const result = [];
+                const infos = await this.readDirectory(parentDir);
+                for (const [name, type] of infos) {
+                    // Exclude paths that start with `.`
+                    if (name.charCodeAt(0) !== CharCode_dot) {
+                        result.push(createCompletionItem(name, type === FileType.Directory, replaceRange));
+                    }
+                }
+                return result;
+            }
+            catch (e) {
+                // ignore
+            }
+        }
+        return [];
+    }
+}
+const CharCode_dot = '.'.charCodeAt(0);
+function stripQuotes(fullValue) {
+    if (startsWith(fullValue, `'`) || startsWith(fullValue, `"`)) {
+        return fullValue.slice(1, -1);
+    }
+    else {
+        return fullValue;
+    }
+}
+function isCompletablePath(value) {
+    if (startsWith(value, 'http') || startsWith(value, 'https') || startsWith(value, '//')) {
+        return false;
+    }
+    return true;
+}
+function pathToReplaceRange(valueBeforeCursor, fullValue, range) {
+    let replaceRange;
+    const lastIndexOfSlash = valueBeforeCursor.lastIndexOf('/');
+    if (lastIndexOfSlash === -1) {
+        replaceRange = shiftRange(range, 1, -1);
+    }
+    else {
+        // For cases where cursor is in the middle of attribute value, like <script src="./s|rc/test.js">
+        // Find the last slash before cursor, and calculate the start of replace range from there
+        const valueAfterLastSlash = fullValue.slice(lastIndexOfSlash + 1);
+        const startPos = shiftPosition(range.end, -1 - valueAfterLastSlash.length);
+        // If whitespace exists, replace until there is no more
+        const whitespaceIndex = valueAfterLastSlash.indexOf(' ');
+        let endPos;
+        if (whitespaceIndex !== -1) {
+            endPos = shiftPosition(startPos, whitespaceIndex);
+        }
+        else {
+            endPos = shiftPosition(range.end, -1);
+        }
+        replaceRange = Range.create(startPos, endPos);
+    }
+    return replaceRange;
+}
+function createCompletionItem(p, isDir, replaceRange) {
+    if (isDir) {
+        p = p + '/';
+        return {
+            label: p,
+            kind: CompletionItemKind.Folder,
+            textEdit: TextEdit.replace(replaceRange, p),
+            command: {
+                title: 'Suggest',
+                command: 'editor.action.triggerSuggest'
+            }
+        };
+    }
+    else {
+        return {
+            label: p,
+            kind: CompletionItemKind.File,
+            textEdit: TextEdit.replace(replaceRange, p)
+        };
+    }
+}
+function shiftPosition(pos, offset) {
+    return Position.create(pos.line, pos.character + offset);
+}
+function shiftRange(range, startOffset, endOffset) {
+    const start = shiftPosition(range.start, startOffset);
+    const end = shiftPosition(range.end, endOffset);
+    return Range.create(start, end);
+}

Java开发环境安装/eclipse-jee-2024-06-R-win32-x86_64/eclipse/plugins/org.eclipse.wildwebdeveloper_1.2.2.202405280856/node_modules/volar-service-html/node_modules/vscode-html-languageservice/lib/esm/utils/arrays.js

@@ -1,3 +1,42 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:65155cf74959d7659234ebd103065d989656aaa031f81037296d6fb1fdb32064
-size 1410
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+/**
+ * Takes a sorted array and a function p. The array is sorted in such a way that all elements where p(x) is false
+ * are located before all elements where p(x) is true.
+ * @returns the least x for which p(x) is true or array.length if no element fullfills the given function.
+ */
+export function findFirst(array, p) {
+    let low = 0, high = array.length;
+    if (high === 0) {
+        return 0; // no children
+    }
+    while (low < high) {
+        let mid = Math.floor((low + high) / 2);
+        if (p(array[mid])) {
+            high = mid;
+        }
+        else {
+            low = mid + 1;
+        }
+    }
+    return low;
+}
+export function binarySearch(array, key, comparator) {
+    let low = 0, high = array.length - 1;
+    while (low <= high) {
+        const mid = ((low + high) / 2) | 0;
+        const comp = comparator(array[mid], key);
+        if (comp < 0) {
+            low = mid + 1;
+        }
+        else if (comp > 0) {
+            high = mid - 1;
+        }
+        else {
+            return mid;
+        }
+    }
+    return -(low + 1);
+}

Java开发环境安装/eclipse-jee-2024-06-R-win32-x86_64/eclipse/plugins/org.eclipse.wildwebdeveloper_1.2.2.202405280856/node_modules/volar-service-html/node_modules/vscode-html-languageservice/lib/esm/utils/markup.js

@@ -1,3 +1,19 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:294f226b77745664d0b7f602ff432651503b555e26fcbb490fa608694049965e
-size 651
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+export function normalizeMarkupContent(input) {
+    if (!input) {
+        return undefined;
+    }
+    if (typeof input === 'string') {
+        return {
+            kind: 'markdown',
+            value: input
+        };
+    }
+    return {
+        kind: 'markdown',
+        value: input.value
+    };
+}

Java开发环境安装/eclipse-jee-2024-06-R-win32-x86_64/eclipse/plugins/org.eclipse.wildwebdeveloper_1.2.2.202405280856/node_modules/volar-service-html/node_modules/vscode-html-languageservice/lib/esm/utils/object.js

@@ -1,3 +1,7 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:238e266b01f24c095fe2bd851d80429d2b35c96a146f2cda5d47e9113e16ecc0
-size 426
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+export function isDefined(obj) {
+    return typeof obj !== 'undefined';
+}

Java开发环境安装/eclipse-jee-2024-06-R-win32-x86_64/eclipse/plugins/org.eclipse.wildwebdeveloper_1.2.2.202405280856/node_modules/volar-service-html/node_modules/vscode-html-languageservice/lib/esm/utils/paths.js

@@ -1,3 +1,64 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:c1f26ceb398d678c3102670d9193f12425cd53f041764dfce485a8046bff1def
-size 2080
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+/**
+ * @returns the directory name of a path.
+ */
+export function dirname(path) {
+    const idx = ~path.lastIndexOf('/') || ~path.lastIndexOf('\\');
+    if (idx === 0) {
+        return '.';
+    }
+    else if (~idx === 0) {
+        return path[0];
+    }
+    else {
+        return path.substring(0, ~idx);
+    }
+}
+/**
+ * @returns the base name of a path.
+ */
+export function basename(path) {
+    const idx = ~path.lastIndexOf('/') || ~path.lastIndexOf('\\');
+    if (idx === 0) {
+        return path;
+    }
+    else if (~idx === path.length - 1) {
+        return basename(path.substring(0, path.length - 1));
+    }
+    else {
+        return path.substr(~idx + 1);
+    }
+}
+/**
+ * @returns {{.far}} from boo.far or the empty string.
+ */
+export function extname(path) {
+    path = basename(path);
+    const idx = ~path.lastIndexOf('.');
+    return idx ? path.substring(~idx) : '';
+}
+export const join = function () {
+    // Not using a function with var-args because of how TS compiles
+    // them to JS - it would result in 2*n runtime cost instead
+    // of 1*n, where n is parts.length.
+    let value = '';
+    for (let i = 0; i < arguments.length; i++) {
+        const part = arguments[i];
+        if (i > 0) {
+            // add the separater between two parts unless
+            // there already is one
+            const last = value.charCodeAt(value.length - 1);
+            if (last !== 47 /* CharCode.Slash */ && last !== 92 /* CharCode.Backslash */) {
+                const next = part.charCodeAt(0);
+                if (next !== 47 /* CharCode.Slash */ && next !== 92 /* CharCode.Backslash */) {
+                    value += '/';
+                }
+            }
+        }
+        value += part;
+    }
+    return value;
+};

Java开发环境安装/eclipse-jee-2024-06-R-win32-x86_64/eclipse/plugins/org.eclipse.wildwebdeveloper_1.2.2.202405280856/node_modules/volar-service-html/node_modules/vscode-html-languageservice/lib/esm/utils/resources.js

@@ -1,3 +1,73 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:2f6ca767541d2572100df6252e51f75d41a7625987d0dcd2ab831fae98bb9eb3
-size 2397
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import { URI } from 'vscode-uri';
+const Slash = '/'.charCodeAt(0);
+const Dot = '.'.charCodeAt(0);
+export function isAbsolutePath(path) {
+    return path.charCodeAt(0) === Slash;
+}
+export function dirname(uri) {
+    const lastIndexOfSlash = uri.lastIndexOf('/');
+    return lastIndexOfSlash !== -1 ? uri.substr(0, lastIndexOfSlash) : '';
+}
+export function basename(uri) {
+    const lastIndexOfSlash = uri.lastIndexOf('/');
+    return uri.substr(lastIndexOfSlash + 1);
+}
+export function extname(uri) {
+    for (let i = uri.length - 1; i >= 0; i--) {
+        const ch = uri.charCodeAt(i);
+        if (ch === Dot) {
+            if (i > 0 && uri.charCodeAt(i - 1) !== Slash) {
+                return uri.substr(i);
+            }
+            else {
+                break;
+            }
+        }
+        else if (ch === Slash) {
+            break;
+        }
+    }
+    return '';
+}
+export function resolvePath(uriString, path) {
+    if (isAbsolutePath(path)) {
+        const uri = URI.parse(uriString);
+        const parts = path.split('/');
+        return uri.with({ path: normalizePath(parts) }).toString();
+    }
+    return joinPath(uriString, path);
+}
+export function normalizePath(parts) {
+    const newParts = [];
+    for (const part of parts) {
+        if (part.length === 0 || part.length === 1 && part.charCodeAt(0) === Dot) {
+            // ignore
+        }
+        else if (part.length === 2 && part.charCodeAt(0) === Dot && part.charCodeAt(1) === Dot) {
+            newParts.pop();
+        }
+        else {
+            newParts.push(part);
+        }
+    }
+    if (parts.length > 1 && parts[parts.length - 1].length === 0) {
+        newParts.push('');
+    }
+    let res = newParts.join('/');
+    if (parts[0].length === 0) {
+        res = '/' + res;
+    }
+    return res;
+}
+export function joinPath(uriString, ...paths) {
+    const uri = URI.parse(uriString);
+    const parts = uri.path.split('/');
+    for (let path of paths) {
+        parts.push(...path.split('/'));
+    }
+    return uri.with({ path: normalizePath(parts) }).toString();
+}

Java开发环境安装/eclipse-jee-2024-06-R-win32-x86_64/eclipse/plugins/org.eclipse.wildwebdeveloper_1.2.2.202405280856/node_modules/volar-service-html/node_modules/vscode-html-languageservice/lib/esm/utils/strings.js

@@ -1,3 +1,64 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:66f00dc4a981a7443c0a313adcbd08e3c56bfeca7dc596224770ce323576a321
-size 1835
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+export function startsWith(haystack, needle) {
+    if (haystack.length < needle.length) {
+        return false;
+    }
+    for (let i = 0; i < needle.length; i++) {
+        if (haystack[i] !== needle[i]) {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * Determines if haystack ends with needle.
+ */
+export function endsWith(haystack, needle) {
+    const diff = haystack.length - needle.length;
+    if (diff > 0) {
+        return haystack.lastIndexOf(needle) === diff;
+    }
+    else if (diff === 0) {
+        return haystack === needle;
+    }
+    else {
+        return false;
+    }
+}
+/**
+ * @returns the length of the common prefix of the two strings.
+ */
+export function commonPrefixLength(a, b) {
+    let i;
+    const len = Math.min(a.length, b.length);
+    for (i = 0; i < len; i++) {
+        if (a.charCodeAt(i) !== b.charCodeAt(i)) {
+            return i;
+        }
+    }
+    return len;
+}
+export function repeat(value, count) {
+    let s = '';
+    while (count > 0) {
+        if ((count & 1) === 1) {
+            s += value;
+        }
+        value += value;
+        count = count >>> 1;
+    }
+    return s;
+}
+const _a = 'a'.charCodeAt(0);
+const _z = 'z'.charCodeAt(0);
+const _A = 'A'.charCodeAt(0);
+const _Z = 'Z'.charCodeAt(0);
+const _0 = '0'.charCodeAt(0);
+const _9 = '9'.charCodeAt(0);
+export function isLetterOrDigit(text, index) {
+    const c = text.charCodeAt(index);
+    return (_a <= c && c <= _z) || (_A <= c && c <= _Z) || (_0 <= c && c <= _9);
+}

Java开发环境安装/eclipse-jee-2024-06-R-win32-x86_64/eclipse/plugins/org.eclipse.wildwebdeveloper_1.2.2.202405280856/node_modules/volar-service-html/node_modules/vscode-html-languageservice/lib/umd/beautify/beautify-css.js

@@ -1,3 +1,1695 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:0385a089a6594f64d36f952f628ce5d2c2ed324717204ab813b3d808f3ef2367
-size 54456
+// copied from js-beautify/js/lib/beautify-css.js
+// version: 1.15.1
+/* AUTO-GENERATED. DO NOT MODIFY. */
+/*
+
+  The MIT License (MIT)
+
+  Copyright (c) 2007-2018 Einar Lielmanis, Liam Newman, and contributors.
+
+  Permission is hereby granted, free of charge, to any person
+  obtaining a copy of this software and associated documentation files
+  (the "Software"), to deal in the Software without restriction,
+  including without limitation the rights to use, copy, modify, merge,
+  publish, distribute, sublicense, and/or sell copies of the Software,
+  and to permit persons to whom the Software is furnished to do so,
+  subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be
+  included in all copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+  BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+  ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+  CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+
+
+ CSS Beautifier
+---------------
+
+    Written by Harutyun Amirjanyan, (amirjanyan@gmail.com)
+
+    Based on code initially developed by: Einar Lielmanis, <einar@beautifier.io>
+        https://beautifier.io/
+
+    Usage:
+        css_beautify(source_text);
+        css_beautify(source_text, options);
+
+    The options are (default in brackets):
+        indent_size (4)                         — indentation size,
+        indent_char (space)                     — character to indent with,
+        selector_separator_newline (true)       - separate selectors with newline or
+                                                  not (e.g. "a,\nbr" or "a, br")
+        end_with_newline (false)                - end with a newline
+        newline_between_rules (true)            - add a new line after every css rule
+        space_around_selector_separator (false) - ensure space around selector separators:
+                                                  '>', '+', '~' (e.g. "a>b" -> "a > b")
+    e.g
+
+    css_beautify(css_source_text, {
+      'indent_size': 1,
+      'indent_char': '\t',
+      'selector_separator': ' ',
+      'end_with_newline': false,
+      'newline_between_rules': true,
+      'space_around_selector_separator': true
+    });
+*/
+
+// http://www.w3.org/TR/CSS21/syndata.html#tokenization
+// http://www.w3.org/TR/css3-syntax/
+
+(function() {
+
+/* GENERATED_BUILD_OUTPUT */
+var legacy_beautify_css;
+/******/ (function() { // webpackBootstrap
+/******/ 	"use strict";
+/******/ 	var __webpack_modules__ = ([
+/* 0 */,
+/* 1 */,
+/* 2 */
+/***/ (function(module) {
+
+/*jshint node:true */
+/*
+  The MIT License (MIT)
+
+  Copyright (c) 2007-2018 Einar Lielmanis, Liam Newman, and contributors.
+
+  Permission is hereby granted, free of charge, to any person
+  obtaining a copy of this software and associated documentation files
+  (the "Software"), to deal in the Software without restriction,
+  including without limitation the rights to use, copy, modify, merge,
+  publish, distribute, sublicense, and/or sell copies of the Software,
+  and to permit persons to whom the Software is furnished to do so,
+  subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be
+  included in all copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+  BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+  ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+  CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+*/
+
+
+
+function OutputLine(parent) {
+  this.__parent = parent;
+  this.__character_count = 0;
+  // use indent_count as a marker for this.__lines that have preserved indentation
+  this.__indent_count = -1;
+  this.__alignment_count = 0;
+  this.__wrap_point_index = 0;
+  this.__wrap_point_character_count = 0;
+  this.__wrap_point_indent_count = -1;
+  this.__wrap_point_alignment_count = 0;
+
+  this.__items = [];
+}
+
+OutputLine.prototype.clone_empty = function() {
+  var line = new OutputLine(this.__parent);
+  line.set_indent(this.__indent_count, this.__alignment_count);
+  return line;
+};
+
+OutputLine.prototype.item = function(index) {
+  if (index < 0) {
+    return this.__items[this.__items.length + index];
+  } else {
+    return this.__items[index];
+  }
+};
+
+OutputLine.prototype.has_match = function(pattern) {
+  for (var lastCheckedOutput = this.__items.length - 1; lastCheckedOutput >= 0; lastCheckedOutput--) {
+    if (this.__items[lastCheckedOutput].match(pattern)) {
+      return true;
+    }
+  }
+  return false;
+};
+
+OutputLine.prototype.set_indent = function(indent, alignment) {
+  if (this.is_empty()) {
+    this.__indent_count = indent || 0;
+    this.__alignment_count = alignment || 0;
+    this.__character_count = this.__parent.get_indent_size(this.__indent_count, this.__alignment_count);
+  }
+};
+
+OutputLine.prototype._set_wrap_point = function() {
+  if (this.__parent.wrap_line_length) {
+    this.__wrap_point_index = this.__items.length;
+    this.__wrap_point_character_count = this.__character_count;
+    this.__wrap_point_indent_count = this.__parent.next_line.__indent_count;
+    this.__wrap_point_alignment_count = this.__parent.next_line.__alignment_count;
+  }
+};
+
+OutputLine.prototype._should_wrap = function() {
+  return this.__wrap_point_index &&
+    this.__character_count > this.__parent.wrap_line_length &&
+    this.__wrap_point_character_count > this.__parent.next_line.__character_count;
+};
+
+OutputLine.prototype._allow_wrap = function() {
+  if (this._should_wrap()) {
+    this.__parent.add_new_line();
+    var next = this.__parent.current_line;
+    next.set_indent(this.__wrap_point_indent_count, this.__wrap_point_alignment_count);
+    next.__items = this.__items.slice(this.__wrap_point_index);
+    this.__items = this.__items.slice(0, this.__wrap_point_index);
+
+    next.__character_count += this.__character_count - this.__wrap_point_character_count;
+    this.__character_count = this.__wrap_point_character_count;
+
+    if (next.__items[0] === " ") {
+      next.__items.splice(0, 1);
+      next.__character_count -= 1;
+    }
+    return true;
+  }
+  return false;
+};
+
+OutputLine.prototype.is_empty = function() {
+  return this.__items.length === 0;
+};
+
+OutputLine.prototype.last = function() {
+  if (!this.is_empty()) {
+    return this.__items[this.__items.length - 1];
+  } else {
+    return null;
+  }
+};
+
+OutputLine.prototype.push = function(item) {
+  this.__items.push(item);
+  var last_newline_index = item.lastIndexOf('\n');
+  if (last_newline_index !== -1) {
+    this.__character_count = item.length - last_newline_index;
+  } else {
+    this.__character_count += item.length;
+  }
+};
+
+OutputLine.prototype.pop = function() {
+  var item = null;
+  if (!this.is_empty()) {
+    item = this.__items.pop();
+    this.__character_count -= item.length;
+  }
+  return item;
+};
+
+
+OutputLine.prototype._remove_indent = function() {
+  if (this.__indent_count > 0) {
+    this.__indent_count -= 1;
+    this.__character_count -= this.__parent.indent_size;
+  }
+};
+
+OutputLine.prototype._remove_wrap_indent = function() {
+  if (this.__wrap_point_indent_count > 0) {
+    this.__wrap_point_indent_count -= 1;
+  }
+};
+OutputLine.prototype.trim = function() {
+  while (this.last() === ' ') {
+    this.__items.pop();
+    this.__character_count -= 1;
+  }
+};
+
+OutputLine.prototype.toString = function() {
+  var result = '';
+  if (this.is_empty()) {
+    if (this.__parent.indent_empty_lines) {
+      result = this.__parent.get_indent_string(this.__indent_count);
+    }
+  } else {
+    result = this.__parent.get_indent_string(this.__indent_count, this.__alignment_count);
+    result += this.__items.join('');
+  }
+  return result;
+};
+
+function IndentStringCache(options, baseIndentString) {
+  this.__cache = [''];
+  this.__indent_size = options.indent_size;
+  this.__indent_string = options.indent_char;
+  if (!options.indent_with_tabs) {
+    this.__indent_string = new Array(options.indent_size + 1).join(options.indent_char);
+  }
+
+  // Set to null to continue support for auto detection of base indent
+  baseIndentString = baseIndentString || '';
+  if (options.indent_level > 0) {
+    baseIndentString = new Array(options.indent_level + 1).join(this.__indent_string);
+  }
+
+  this.__base_string = baseIndentString;
+  this.__base_string_length = baseIndentString.length;
+}
+
+IndentStringCache.prototype.get_indent_size = function(indent, column) {
+  var result = this.__base_string_length;
+  column = column || 0;
+  if (indent < 0) {
+    result = 0;
+  }
+  result += indent * this.__indent_size;
+  result += column;
+  return result;
+};
+
+IndentStringCache.prototype.get_indent_string = function(indent_level, column) {
+  var result = this.__base_string;
+  column = column || 0;
+  if (indent_level < 0) {
+    indent_level = 0;
+    result = '';
+  }
+  column += indent_level * this.__indent_size;
+  this.__ensure_cache(column);
+  result += this.__cache[column];
+  return result;
+};
+
+IndentStringCache.prototype.__ensure_cache = function(column) {
+  while (column >= this.__cache.length) {
+    this.__add_column();
+  }
+};
+
+IndentStringCache.prototype.__add_column = function() {
+  var column = this.__cache.length;
+  var indent = 0;
+  var result = '';
+  if (this.__indent_size && column >= this.__indent_size) {
+    indent = Math.floor(column / this.__indent_size);
+    column -= indent * this.__indent_size;
+    result = new Array(indent + 1).join(this.__indent_string);
+  }
+  if (column) {
+    result += new Array(column + 1).join(' ');
+  }
+
+  this.__cache.push(result);
+};
+
+function Output(options, baseIndentString) {
+  this.__indent_cache = new IndentStringCache(options, baseIndentString);
+  this.raw = false;
+  this._end_with_newline = options.end_with_newline;
+  this.indent_size = options.indent_size;
+  this.wrap_line_length = options.wrap_line_length;
+  this.indent_empty_lines = options.indent_empty_lines;
+  this.__lines = [];
+  this.previous_line = null;
+  this.current_line = null;
+  this.next_line = new OutputLine(this);
+  this.space_before_token = false;
+  this.non_breaking_space = false;
+  this.previous_token_wrapped = false;
+  // initialize
+  this.__add_outputline();
+}
+
+Output.prototype.__add_outputline = function() {
+  this.previous_line = this.current_line;
+  this.current_line = this.next_line.clone_empty();
+  this.__lines.push(this.current_line);
+};
+
+Output.prototype.get_line_number = function() {
+  return this.__lines.length;
+};
+
+Output.prototype.get_indent_string = function(indent, column) {
+  return this.__indent_cache.get_indent_string(indent, column);
+};
+
+Output.prototype.get_indent_size = function(indent, column) {
+  return this.__indent_cache.get_indent_size(indent, column);
+};
+
+Output.prototype.is_empty = function() {
+  return !this.previous_line && this.current_line.is_empty();
+};
+
+Output.prototype.add_new_line = function(force_newline) {
+  // never newline at the start of file
+  // otherwise, newline only if we didn't just add one or we're forced
+  if (this.is_empty() ||
+    (!force_newline && this.just_added_newline())) {
+    return false;
+  }
+
+  // if raw output is enabled, don't print additional newlines,
+  // but still return True as though you had
+  if (!this.raw) {
+    this.__add_outputline();
+  }
+  return true;
+};
+
+Output.prototype.get_code = function(eol) {
+  this.trim(true);
+
+  // handle some edge cases where the last tokens
+  // has text that ends with newline(s)
+  var last_item = this.current_line.pop();
+  if (last_item) {
+    if (last_item[last_item.length - 1] === '\n') {
+      last_item = last_item.replace(/\n+$/g, '');
+    }
+    this.current_line.push(last_item);
+  }
+
+  if (this._end_with_newline) {
+    this.__add_outputline();
+  }
+
+  var sweet_code = this.__lines.join('\n');
+
+  if (eol !== '\n') {
+    sweet_code = sweet_code.replace(/[\n]/g, eol);
+  }
+  return sweet_code;
+};
+
+Output.prototype.set_wrap_point = function() {
+  this.current_line._set_wrap_point();
+};
+
+Output.prototype.set_indent = function(indent, alignment) {
+  indent = indent || 0;
+  alignment = alignment || 0;
+
+  // Next line stores alignment values
+  this.next_line.set_indent(indent, alignment);
+
+  // Never indent your first output indent at the start of the file
+  if (this.__lines.length > 1) {
+    this.current_line.set_indent(indent, alignment);
+    return true;
+  }
+
+  this.current_line.set_indent();
+  return false;
+};
+
+Output.prototype.add_raw_token = function(token) {
+  for (var x = 0; x < token.newlines; x++) {
+    this.__add_outputline();
+  }
+  this.current_line.set_indent(-1);
+  this.current_line.push(token.whitespace_before);
+  this.current_line.push(token.text);
+  this.space_before_token = false;
+  this.non_breaking_space = false;
+  this.previous_token_wrapped = false;
+};
+
+Output.prototype.add_token = function(printable_token) {
+  this.__add_space_before_token();
+  this.current_line.push(printable_token);
+  this.space_before_token = false;
+  this.non_breaking_space = false;
+  this.previous_token_wrapped = this.current_line._allow_wrap();
+};
+
+Output.prototype.__add_space_before_token = function() {
+  if (this.space_before_token && !this.just_added_newline()) {
+    if (!this.non_breaking_space) {
+      this.set_wrap_point();
+    }
+    this.current_line.push(' ');
+  }
+};
+
+Output.prototype.remove_indent = function(index) {
+  var output_length = this.__lines.length;
+  while (index < output_length) {
+    this.__lines[index]._remove_indent();
+    index++;
+  }
+  this.current_line._remove_wrap_indent();
+};
+
+Output.prototype.trim = function(eat_newlines) {
+  eat_newlines = (eat_newlines === undefined) ? false : eat_newlines;
+
+  this.current_line.trim();
+
+  while (eat_newlines && this.__lines.length > 1 &&
+    this.current_line.is_empty()) {
+    this.__lines.pop();
+    this.current_line = this.__lines[this.__lines.length - 1];
+    this.current_line.trim();
+  }
+
+  this.previous_line = this.__lines.length > 1 ?
+    this.__lines[this.__lines.length - 2] : null;
+};
+
+Output.prototype.just_added_newline = function() {
+  return this.current_line.is_empty();
+};
+
+Output.prototype.just_added_blankline = function() {
+  return this.is_empty() ||
+    (this.current_line.is_empty() && this.previous_line.is_empty());
+};
+
+Output.prototype.ensure_empty_line_above = function(starts_with, ends_with) {
+  var index = this.__lines.length - 2;
+  while (index >= 0) {
+    var potentialEmptyLine = this.__lines[index];
+    if (potentialEmptyLine.is_empty()) {
+      break;
+    } else if (potentialEmptyLine.item(0).indexOf(starts_with) !== 0 &&
+      potentialEmptyLine.item(-1) !== ends_with) {
+      this.__lines.splice(index + 1, 0, new OutputLine(this));
+      this.previous_line = this.__lines[this.__lines.length - 2];
+      break;
+    }
+    index--;
+  }
+};
+
+module.exports.Output = Output;
+
+
+/***/ }),
+/* 3 */,
+/* 4 */,
+/* 5 */,
+/* 6 */
+/***/ (function(module) {
+
+/*jshint node:true */
+/*
+
+  The MIT License (MIT)
+
+  Copyright (c) 2007-2018 Einar Lielmanis, Liam Newman, and contributors.
+
+  Permission is hereby granted, free of charge, to any person
+  obtaining a copy of this software and associated documentation files
+  (the "Software"), to deal in the Software without restriction,
+  including without limitation the rights to use, copy, modify, merge,
+  publish, distribute, sublicense, and/or sell copies of the Software,
+  and to permit persons to whom the Software is furnished to do so,
+  subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be
+  included in all copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+  BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+  ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+  CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+*/
+
+
+
+function Options(options, merge_child_field) {
+  this.raw_options = _mergeOpts(options, merge_child_field);
+
+  // Support passing the source text back with no change
+  this.disabled = this._get_boolean('disabled');
+
+  this.eol = this._get_characters('eol', 'auto');
+  this.end_with_newline = this._get_boolean('end_with_newline');
+  this.indent_size = this._get_number('indent_size', 4);
+  this.indent_char = this._get_characters('indent_char', ' ');
+  this.indent_level = this._get_number('indent_level');
+
+  this.preserve_newlines = this._get_boolean('preserve_newlines', true);
+  this.max_preserve_newlines = this._get_number('max_preserve_newlines', 32786);
+  if (!this.preserve_newlines) {
+    this.max_preserve_newlines = 0;
+  }
+
+  this.indent_with_tabs = this._get_boolean('indent_with_tabs', this.indent_char === '\t');
+  if (this.indent_with_tabs) {
+    this.indent_char = '\t';
+
+    // indent_size behavior changed after 1.8.6
+    // It used to be that indent_size would be
+    // set to 1 for indent_with_tabs. That is no longer needed and
+    // actually doesn't make sense - why not use spaces? Further,
+    // that might produce unexpected behavior - tabs being used
+    // for single-column alignment. So, when indent_with_tabs is true
+    // and indent_size is 1, reset indent_size to 4.
+    if (this.indent_size === 1) {
+      this.indent_size = 4;
+    }
+  }
+
+  // Backwards compat with 1.3.x
+  this.wrap_line_length = this._get_number('wrap_line_length', this._get_number('max_char'));
+
+  this.indent_empty_lines = this._get_boolean('indent_empty_lines');
+
+  // valid templating languages ['django', 'erb', 'handlebars', 'php', 'smarty', 'angular']
+  // For now, 'auto' = all off for javascript, all except angular on for html (and inline javascript/css).
+  // other values ignored
+  this.templating = this._get_selection_list('templating', ['auto', 'none', 'angular', 'django', 'erb', 'handlebars', 'php', 'smarty'], ['auto']);
+}
+
+Options.prototype._get_array = function(name, default_value) {
+  var option_value = this.raw_options[name];
+  var result = default_value || [];
+  if (typeof option_value === 'object') {
+    if (option_value !== null && typeof option_value.concat === 'function') {
+      result = option_value.concat();
+    }
+  } else if (typeof option_value === 'string') {
+    result = option_value.split(/[^a-zA-Z0-9_\/\-]+/);
+  }
+  return result;
+};
+
+Options.prototype._get_boolean = function(name, default_value) {
+  var option_value = this.raw_options[name];
+  var result = option_value === undefined ? !!default_value : !!option_value;
+  return result;
+};
+
+Options.prototype._get_characters = function(name, default_value) {
+  var option_value = this.raw_options[name];
+  var result = default_value || '';
+  if (typeof option_value === 'string') {
+    result = option_value.replace(/\\r/, '\r').replace(/\\n/, '\n').replace(/\\t/, '\t');
+  }
+  return result;
+};
+
+Options.prototype._get_number = function(name, default_value) {
+  var option_value = this.raw_options[name];
+  default_value = parseInt(default_value, 10);
+  if (isNaN(default_value)) {
+    default_value = 0;
+  }
+  var result = parseInt(option_value, 10);
+  if (isNaN(result)) {
+    result = default_value;
+  }
+  return result;
+};
+
+Options.prototype._get_selection = function(name, selection_list, default_value) {
+  var result = this._get_selection_list(name, selection_list, default_value);
+  if (result.length !== 1) {
+    throw new Error(
+      "Invalid Option Value: The option '" + name + "' can only be one of the following values:\n" +
+      selection_list + "\nYou passed in: '" + this.raw_options[name] + "'");
+  }
+
+  return result[0];
+};
+
+
+Options.prototype._get_selection_list = function(name, selection_list, default_value) {
+  if (!selection_list || selection_list.length === 0) {
+    throw new Error("Selection list cannot be empty.");
+  }
+
+  default_value = default_value || [selection_list[0]];
+  if (!this._is_valid_selection(default_value, selection_list)) {
+    throw new Error("Invalid Default Value!");
+  }
+
+  var result = this._get_array(name, default_value);
+  if (!this._is_valid_selection(result, selection_list)) {
+    throw new Error(
+      "Invalid Option Value: The option '" + name + "' can contain only the following values:\n" +
+      selection_list + "\nYou passed in: '" + this.raw_options[name] + "'");
+  }
+
+  return result;
+};
+
+Options.prototype._is_valid_selection = function(result, selection_list) {
+  return result.length && selection_list.length &&
+    !result.some(function(item) { return selection_list.indexOf(item) === -1; });
+};
+
+
+// merges child options up with the parent options object
+// Example: obj = {a: 1, b: {a: 2}}
+//          mergeOpts(obj, 'b')
+//
+//          Returns: {a: 2}
+function _mergeOpts(allOptions, childFieldName) {
+  var finalOpts = {};
+  allOptions = _normalizeOpts(allOptions);
+  var name;
+
+  for (name in allOptions) {
+    if (name !== childFieldName) {
+      finalOpts[name] = allOptions[name];
+    }
+  }
+
+  //merge in the per type settings for the childFieldName
+  if (childFieldName && allOptions[childFieldName]) {
+    for (name in allOptions[childFieldName]) {
+      finalOpts[name] = allOptions[childFieldName][name];
+    }
+  }
+  return finalOpts;
+}
+
+function _normalizeOpts(options) {
+  var convertedOpts = {};
+  var key;
+
+  for (key in options) {
+    var newKey = key.replace(/-/g, "_");
+    convertedOpts[newKey] = options[key];
+  }
+  return convertedOpts;
+}
+
+module.exports.Options = Options;
+module.exports.normalizeOpts = _normalizeOpts;
+module.exports.mergeOpts = _mergeOpts;
+
+
+/***/ }),
+/* 7 */,
+/* 8 */
+/***/ (function(module) {
+
+/*jshint node:true */
+/*
+
+  The MIT License (MIT)
+
+  Copyright (c) 2007-2018 Einar Lielmanis, Liam Newman, and contributors.
+
+  Permission is hereby granted, free of charge, to any person
+  obtaining a copy of this software and associated documentation files
+  (the "Software"), to deal in the Software without restriction,
+  including without limitation the rights to use, copy, modify, merge,
+  publish, distribute, sublicense, and/or sell copies of the Software,
+  and to permit persons to whom the Software is furnished to do so,
+  subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be
+  included in all copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+  BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+  ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+  CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+*/
+
+
+
+var regexp_has_sticky = RegExp.prototype.hasOwnProperty('sticky');
+
+function InputScanner(input_string) {
+  this.__input = input_string || '';
+  this.__input_length = this.__input.length;
+  this.__position = 0;
+}
+
+InputScanner.prototype.restart = function() {
+  this.__position = 0;
+};
+
+InputScanner.prototype.back = function() {
+  if (this.__position > 0) {
+    this.__position -= 1;
+  }
+};
+
+InputScanner.prototype.hasNext = function() {
+  return this.__position < this.__input_length;
+};
+
+InputScanner.prototype.next = function() {
+  var val = null;
+  if (this.hasNext()) {
+    val = this.__input.charAt(this.__position);
+    this.__position += 1;
+  }
+  return val;
+};
+
+InputScanner.prototype.peek = function(index) {
+  var val = null;
+  index = index || 0;
+  index += this.__position;
+  if (index >= 0 && index < this.__input_length) {
+    val = this.__input.charAt(index);
+  }
+  return val;
+};
+
+// This is a JavaScript only helper function (not in python)
+// Javascript doesn't have a match method
+// and not all implementation support "sticky" flag.
+// If they do not support sticky then both this.match() and this.test() method
+// must get the match and check the index of the match.
+// If sticky is supported and set, this method will use it.
+// Otherwise it will check that global is set, and fall back to the slower method.
+InputScanner.prototype.__match = function(pattern, index) {
+  pattern.lastIndex = index;
+  var pattern_match = pattern.exec(this.__input);
+
+  if (pattern_match && !(regexp_has_sticky && pattern.sticky)) {
+    if (pattern_match.index !== index) {
+      pattern_match = null;
+    }
+  }
+
+  return pattern_match;
+};
+
+InputScanner.prototype.test = function(pattern, index) {
+  index = index || 0;
+  index += this.__position;
+
+  if (index >= 0 && index < this.__input_length) {
+    return !!this.__match(pattern, index);
+  } else {
+    return false;
+  }
+};
+
+InputScanner.prototype.testChar = function(pattern, index) {
+  // test one character regex match
+  var val = this.peek(index);
+  pattern.lastIndex = 0;
+  return val !== null && pattern.test(val);
+};
+
+InputScanner.prototype.match = function(pattern) {
+  var pattern_match = this.__match(pattern, this.__position);
+  if (pattern_match) {
+    this.__position += pattern_match[0].length;
+  } else {
+    pattern_match = null;
+  }
+  return pattern_match;
+};
+
+InputScanner.prototype.read = function(starting_pattern, until_pattern, until_after) {
+  var val = '';
+  var match;
+  if (starting_pattern) {
+    match = this.match(starting_pattern);
+    if (match) {
+      val += match[0];
+    }
+  }
+  if (until_pattern && (match || !starting_pattern)) {
+    val += this.readUntil(until_pattern, until_after);
+  }
+  return val;
+};
+
+InputScanner.prototype.readUntil = function(pattern, until_after) {
+  var val = '';
+  var match_index = this.__position;
+  pattern.lastIndex = this.__position;
+  var pattern_match = pattern.exec(this.__input);
+  if (pattern_match) {
+    match_index = pattern_match.index;
+    if (until_after) {
+      match_index += pattern_match[0].length;
+    }
+  } else {
+    match_index = this.__input_length;
+  }
+
+  val = this.__input.substring(this.__position, match_index);
+  this.__position = match_index;
+  return val;
+};
+
+InputScanner.prototype.readUntilAfter = function(pattern) {
+  return this.readUntil(pattern, true);
+};
+
+InputScanner.prototype.get_regexp = function(pattern, match_from) {
+  var result = null;
+  var flags = 'g';
+  if (match_from && regexp_has_sticky) {
+    flags = 'y';
+  }
+  // strings are converted to regexp
+  if (typeof pattern === "string" && pattern !== '') {
+    // result = new RegExp(pattern.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&'), flags);
+    result = new RegExp(pattern, flags);
+  } else if (pattern) {
+    result = new RegExp(pattern.source, flags);
+  }
+  return result;
+};
+
+InputScanner.prototype.get_literal_regexp = function(literal_string) {
+  return RegExp(literal_string.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&'));
+};
+
+/* css beautifier legacy helpers */
+InputScanner.prototype.peekUntilAfter = function(pattern) {
+  var start = this.__position;
+  var val = this.readUntilAfter(pattern);
+  this.__position = start;
+  return val;
+};
+
+InputScanner.prototype.lookBack = function(testVal) {
+  var start = this.__position - 1;
+  return start >= testVal.length && this.__input.substring(start - testVal.length, start)
+    .toLowerCase() === testVal;
+};
+
+module.exports.InputScanner = InputScanner;
+
+
+/***/ }),
+/* 9 */,
+/* 10 */,
+/* 11 */,
+/* 12 */,
+/* 13 */
+/***/ (function(module) {
+
+/*jshint node:true */
+/*
+
+  The MIT License (MIT)
+
+  Copyright (c) 2007-2018 Einar Lielmanis, Liam Newman, and contributors.
+
+  Permission is hereby granted, free of charge, to any person
+  obtaining a copy of this software and associated documentation files
+  (the "Software"), to deal in the Software without restriction,
+  including without limitation the rights to use, copy, modify, merge,
+  publish, distribute, sublicense, and/or sell copies of the Software,
+  and to permit persons to whom the Software is furnished to do so,
+  subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be
+  included in all copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+  BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+  ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+  CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+*/
+
+
+
+function Directives(start_block_pattern, end_block_pattern) {
+  start_block_pattern = typeof start_block_pattern === 'string' ? start_block_pattern : start_block_pattern.source;
+  end_block_pattern = typeof end_block_pattern === 'string' ? end_block_pattern : end_block_pattern.source;
+  this.__directives_block_pattern = new RegExp(start_block_pattern + / beautify( \w+[:]\w+)+ /.source + end_block_pattern, 'g');
+  this.__directive_pattern = / (\w+)[:](\w+)/g;
+
+  this.__directives_end_ignore_pattern = new RegExp(start_block_pattern + /\sbeautify\signore:end\s/.source + end_block_pattern, 'g');
+}
+
+Directives.prototype.get_directives = function(text) {
+  if (!text.match(this.__directives_block_pattern)) {
+    return null;
+  }
+
+  var directives = {};
+  this.__directive_pattern.lastIndex = 0;
+  var directive_match = this.__directive_pattern.exec(text);
+
+  while (directive_match) {
+    directives[directive_match[1]] = directive_match[2];
+    directive_match = this.__directive_pattern.exec(text);
+  }
+
+  return directives;
+};
+
+Directives.prototype.readIgnored = function(input) {
+  return input.readUntilAfter(this.__directives_end_ignore_pattern);
+};
+
+
+module.exports.Directives = Directives;
+
+
+/***/ }),
+/* 14 */,
+/* 15 */
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+/*jshint node:true */
+/*
+
+  The MIT License (MIT)
+
+  Copyright (c) 2007-2018 Einar Lielmanis, Liam Newman, and contributors.
+
+  Permission is hereby granted, free of charge, to any person
+  obtaining a copy of this software and associated documentation files
+  (the "Software"), to deal in the Software without restriction,
+  including without limitation the rights to use, copy, modify, merge,
+  publish, distribute, sublicense, and/or sell copies of the Software,
+  and to permit persons to whom the Software is furnished to do so,
+  subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be
+  included in all copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+  BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+  ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+  CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+*/
+
+
+
+var Beautifier = (__webpack_require__(16).Beautifier),
+  Options = (__webpack_require__(17).Options);
+
+function css_beautify(source_text, options) {
+  var beautifier = new Beautifier(source_text, options);
+  return beautifier.beautify();
+}
+
+module.exports = css_beautify;
+module.exports.defaultOptions = function() {
+  return new Options();
+};
+
+
+/***/ }),
+/* 16 */
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+/*jshint node:true */
+/*
+
+  The MIT License (MIT)
+
+  Copyright (c) 2007-2018 Einar Lielmanis, Liam Newman, and contributors.
+
+  Permission is hereby granted, free of charge, to any person
+  obtaining a copy of this software and associated documentation files
+  (the "Software"), to deal in the Software without restriction,
+  including without limitation the rights to use, copy, modify, merge,
+  publish, distribute, sublicense, and/or sell copies of the Software,
+  and to permit persons to whom the Software is furnished to do so,
+  subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be
+  included in all copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+  BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+  ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+  CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+*/
+
+
+
+var Options = (__webpack_require__(17).Options);
+var Output = (__webpack_require__(2).Output);
+var InputScanner = (__webpack_require__(8).InputScanner);
+var Directives = (__webpack_require__(13).Directives);
+
+var directives_core = new Directives(/\/\*/, /\*\//);
+
+var lineBreak = /\r\n|[\r\n]/;
+var allLineBreaks = /\r\n|[\r\n]/g;
+
+// tokenizer
+var whitespaceChar = /\s/;
+var whitespacePattern = /(?:\s|\n)+/g;
+var block_comment_pattern = /\/\*(?:[\s\S]*?)((?:\*\/)|$)/g;
+var comment_pattern = /\/\/(?:[^\n\r\u2028\u2029]*)/g;
+
+function Beautifier(source_text, options) {
+  this._source_text = source_text || '';
+  // Allow the setting of language/file-type specific options
+  // with inheritance of overall settings
+  this._options = new Options(options);
+  this._ch = null;
+  this._input = null;
+
+  // https://developer.mozilla.org/en-US/docs/Web/CSS/At-rule
+  this.NESTED_AT_RULE = {
+    "page": true,
+    "font-face": true,
+    "keyframes": true,
+    // also in CONDITIONAL_GROUP_RULE below
+    "media": true,
+    "supports": true,
+    "document": true
+  };
+  this.CONDITIONAL_GROUP_RULE = {
+    "media": true,
+    "supports": true,
+    "document": true
+  };
+  this.NON_SEMICOLON_NEWLINE_PROPERTY = [
+    "grid-template-areas",
+    "grid-template"
+  ];
+
+}
+
+Beautifier.prototype.eatString = function(endChars) {
+  var result = '';
+  this._ch = this._input.next();
+  while (this._ch) {
+    result += this._ch;
+    if (this._ch === "\\") {
+      result += this._input.next();
+    } else if (endChars.indexOf(this._ch) !== -1 || this._ch === "\n") {
+      break;
+    }
+    this._ch = this._input.next();
+  }
+  return result;
+};
+
+// Skips any white space in the source text from the current position.
+// When allowAtLeastOneNewLine is true, will output new lines for each
+// newline character found; if the user has preserve_newlines off, only
+// the first newline will be output
+Beautifier.prototype.eatWhitespace = function(allowAtLeastOneNewLine) {
+  var result = whitespaceChar.test(this._input.peek());
+  var newline_count = 0;
+  while (whitespaceChar.test(this._input.peek())) {
+    this._ch = this._input.next();
+    if (allowAtLeastOneNewLine && this._ch === '\n') {
+      if (newline_count === 0 || newline_count < this._options.max_preserve_newlines) {
+        newline_count++;
+        this._output.add_new_line(true);
+      }
+    }
+  }
+  return result;
+};
+
+// Nested pseudo-class if we are insideRule
+// and the next special character found opens
+// a new block
+Beautifier.prototype.foundNestedPseudoClass = function() {
+  var openParen = 0;
+  var i = 1;
+  var ch = this._input.peek(i);
+  while (ch) {
+    if (ch === "{") {
+      return true;
+    } else if (ch === '(') {
+      // pseudoclasses can contain ()
+      openParen += 1;
+    } else if (ch === ')') {
+      if (openParen === 0) {
+        return false;
+      }
+      openParen -= 1;
+    } else if (ch === ";" || ch === "}") {
+      return false;
+    }
+    i++;
+    ch = this._input.peek(i);
+  }
+  return false;
+};
+
+Beautifier.prototype.print_string = function(output_string) {
+  this._output.set_indent(this._indentLevel);
+  this._output.non_breaking_space = true;
+  this._output.add_token(output_string);
+};
+
+Beautifier.prototype.preserveSingleSpace = function(isAfterSpace) {
+  if (isAfterSpace) {
+    this._output.space_before_token = true;
+  }
+};
+
+Beautifier.prototype.indent = function() {
+  this._indentLevel++;
+};
+
+Beautifier.prototype.outdent = function() {
+  if (this._indentLevel > 0) {
+    this._indentLevel--;
+  }
+};
+
+/*_____________________--------------------_____________________*/
+
+Beautifier.prototype.beautify = function() {
+  if (this._options.disabled) {
+    return this._source_text;
+  }
+
+  var source_text = this._source_text;
+  var eol = this._options.eol;
+  if (eol === 'auto') {
+    eol = '\n';
+    if (source_text && lineBreak.test(source_text || '')) {
+      eol = source_text.match(lineBreak)[0];
+    }
+  }
+
+
+  // HACK: newline parsing inconsistent. This brute force normalizes the this._input.
+  source_text = source_text.replace(allLineBreaks, '\n');
+
+  // reset
+  var baseIndentString = source_text.match(/^[\t ]*/)[0];
+
+  this._output = new Output(this._options, baseIndentString);
+  this._input = new InputScanner(source_text);
+  this._indentLevel = 0;
+  this._nestedLevel = 0;
+
+  this._ch = null;
+  var parenLevel = 0;
+
+  var insideRule = false;
+  // This is the value side of a property value pair (blue in the following ex)
+  // label { content: blue }
+  var insidePropertyValue = false;
+  var enteringConditionalGroup = false;
+  var insideNonNestedAtRule = false;
+  var insideScssMap = false;
+  var topCharacter = this._ch;
+  var insideNonSemiColonValues = false;
+  var whitespace;
+  var isAfterSpace;
+  var previous_ch;
+
+  while (true) {
+    whitespace = this._input.read(whitespacePattern);
+    isAfterSpace = whitespace !== '';
+    previous_ch = topCharacter;
+    this._ch = this._input.next();
+    if (this._ch === '\\' && this._input.hasNext()) {
+      this._ch += this._input.next();
+    }
+    topCharacter = this._ch;
+
+    if (!this._ch) {
+      break;
+    } else if (this._ch === '/' && this._input.peek() === '*') {
+      // /* css comment */
+      // Always start block comments on a new line.
+      // This handles scenarios where a block comment immediately
+      // follows a property definition on the same line or where
+      // minified code is being beautified.
+      this._output.add_new_line();
+      this._input.back();
+
+      var comment = this._input.read(block_comment_pattern);
+
+      // Handle ignore directive
+      var directives = directives_core.get_directives(comment);
+      if (directives && directives.ignore === 'start') {
+        comment += directives_core.readIgnored(this._input);
+      }
+
+      this.print_string(comment);
+
+      // Ensures any new lines following the comment are preserved
+      this.eatWhitespace(true);
+
+      // Block comments are followed by a new line so they don't
+      // share a line with other properties
+      this._output.add_new_line();
+    } else if (this._ch === '/' && this._input.peek() === '/') {
+      // // single line comment
+      // Preserves the space before a comment
+      // on the same line as a rule
+      this._output.space_before_token = true;
+      this._input.back();
+      this.print_string(this._input.read(comment_pattern));
+
+      // Ensures any new lines following the comment are preserved
+      this.eatWhitespace(true);
+    } else if (this._ch === '$') {
+      this.preserveSingleSpace(isAfterSpace);
+
+      this.print_string(this._ch);
+
+      // strip trailing space, if present, for hash property checks
+      var variable = this._input.peekUntilAfter(/[: ,;{}()[\]\/='"]/g);
+
+      if (variable.match(/[ :]$/)) {
+        // we have a variable or pseudo-class, add it and insert one space before continuing
+        variable = this.eatString(": ").replace(/\s+$/, '');
+        this.print_string(variable);
+        this._output.space_before_token = true;
+      }
+
+      // might be sass variable
+      if (parenLevel === 0 && variable.indexOf(':') !== -1) {
+        insidePropertyValue = true;
+        this.indent();
+      }
+    } else if (this._ch === '@') {
+      this.preserveSingleSpace(isAfterSpace);
+
+      // deal with less property mixins @{...}
+      if (this._input.peek() === '{') {
+        this.print_string(this._ch + this.eatString('}'));
+      } else {
+        this.print_string(this._ch);
+
+        // strip trailing space, if present, for hash property checks
+        var variableOrRule = this._input.peekUntilAfter(/[: ,;{}()[\]\/='"]/g);
+
+        if (variableOrRule.match(/[ :]$/)) {
+          // we have a variable or pseudo-class, add it and insert one space before continuing
+          variableOrRule = this.eatString(": ").replace(/\s+$/, '');
+          this.print_string(variableOrRule);
+          this._output.space_before_token = true;
+        }
+
+        // might be less variable
+        if (parenLevel === 0 && variableOrRule.indexOf(':') !== -1) {
+          insidePropertyValue = true;
+          this.indent();
+
+          // might be a nesting at-rule
+        } else if (variableOrRule in this.NESTED_AT_RULE) {
+          this._nestedLevel += 1;
+          if (variableOrRule in this.CONDITIONAL_GROUP_RULE) {
+            enteringConditionalGroup = true;
+          }
+
+          // might be a non-nested at-rule
+        } else if (parenLevel === 0 && !insidePropertyValue) {
+          insideNonNestedAtRule = true;
+        }
+      }
+    } else if (this._ch === '#' && this._input.peek() === '{') {
+      this.preserveSingleSpace(isAfterSpace);
+      this.print_string(this._ch + this.eatString('}'));
+    } else if (this._ch === '{') {
+      if (insidePropertyValue) {
+        insidePropertyValue = false;
+        this.outdent();
+      }
+
+      // non nested at rule becomes nested
+      insideNonNestedAtRule = false;
+
+      // when entering conditional groups, only rulesets are allowed
+      if (enteringConditionalGroup) {
+        enteringConditionalGroup = false;
+        insideRule = (this._indentLevel >= this._nestedLevel);
+      } else {
+        // otherwise, declarations are also allowed
+        insideRule = (this._indentLevel >= this._nestedLevel - 1);
+      }
+      if (this._options.newline_between_rules && insideRule) {
+        if (this._output.previous_line && this._output.previous_line.item(-1) !== '{') {
+          this._output.ensure_empty_line_above('/', ',');
+        }
+      }
+
+      this._output.space_before_token = true;
+
+      // The difference in print_string and indent order is necessary to indent the '{' correctly
+      if (this._options.brace_style === 'expand') {
+        this._output.add_new_line();
+        this.print_string(this._ch);
+        this.indent();
+        this._output.set_indent(this._indentLevel);
+      } else {
+        // inside mixin and first param is object
+        if (previous_ch === '(') {
+          this._output.space_before_token = false;
+        } else if (previous_ch !== ',') {
+          this.indent();
+        }
+        this.print_string(this._ch);
+      }
+
+      this.eatWhitespace(true);
+      this._output.add_new_line();
+    } else if (this._ch === '}') {
+      this.outdent();
+      this._output.add_new_line();
+      if (previous_ch === '{') {
+        this._output.trim(true);
+      }
+
+      if (insidePropertyValue) {
+        this.outdent();
+        insidePropertyValue = false;
+      }
+      this.print_string(this._ch);
+      insideRule = false;
+      if (this._nestedLevel) {
+        this._nestedLevel--;
+      }
+
+      this.eatWhitespace(true);
+      this._output.add_new_line();
+
+      if (this._options.newline_between_rules && !this._output.just_added_blankline()) {
+        if (this._input.peek() !== '}') {
+          this._output.add_new_line(true);
+        }
+      }
+      if (this._input.peek() === ')') {
+        this._output.trim(true);
+        if (this._options.brace_style === "expand") {
+          this._output.add_new_line(true);
+        }
+      }
+    } else if (this._ch === ":") {
+
+      for (var i = 0; i < this.NON_SEMICOLON_NEWLINE_PROPERTY.length; i++) {
+        if (this._input.lookBack(this.NON_SEMICOLON_NEWLINE_PROPERTY[i])) {
+          insideNonSemiColonValues = true;
+          break;
+        }
+      }
+
+      if ((insideRule || enteringConditionalGroup) && !(this._input.lookBack("&") || this.foundNestedPseudoClass()) && !this._input.lookBack("(") && !insideNonNestedAtRule && parenLevel === 0) {
+        // 'property: value' delimiter
+        // which could be in a conditional group query
+
+        this.print_string(':');
+        if (!insidePropertyValue) {
+          insidePropertyValue = true;
+          this._output.space_before_token = true;
+          this.eatWhitespace(true);
+          this.indent();
+        }
+      } else {
+        // sass/less parent reference don't use a space
+        // sass nested pseudo-class don't use a space
+
+        // preserve space before pseudoclasses/pseudoelements, as it means "in any child"
+        if (this._input.lookBack(" ")) {
+          this._output.space_before_token = true;
+        }
+        if (this._input.peek() === ":") {
+          // pseudo-element
+          this._ch = this._input.next();
+          this.print_string("::");
+        } else {
+          // pseudo-class
+          this.print_string(':');
+        }
+      }
+    } else if (this._ch === '"' || this._ch === '\'') {
+      var preserveQuoteSpace = previous_ch === '"' || previous_ch === '\'';
+      this.preserveSingleSpace(preserveQuoteSpace || isAfterSpace);
+      this.print_string(this._ch + this.eatString(this._ch));
+      this.eatWhitespace(true);
+    } else if (this._ch === ';') {
+      insideNonSemiColonValues = false;
+      if (parenLevel === 0) {
+        if (insidePropertyValue) {
+          this.outdent();
+          insidePropertyValue = false;
+        }
+        insideNonNestedAtRule = false;
+        this.print_string(this._ch);
+        this.eatWhitespace(true);
+
+        // This maintains single line comments on the same
+        // line. Block comments are also affected, but
+        // a new line is always output before one inside
+        // that section
+        if (this._input.peek() !== '/') {
+          this._output.add_new_line();
+        }
+      } else {
+        this.print_string(this._ch);
+        this.eatWhitespace(true);
+        this._output.space_before_token = true;
+      }
+    } else if (this._ch === '(') { // may be a url
+      if (this._input.lookBack("url")) {
+        this.print_string(this._ch);
+        this.eatWhitespace();
+        parenLevel++;
+        this.indent();
+        this._ch = this._input.next();
+        if (this._ch === ')' || this._ch === '"' || this._ch === '\'') {
+          this._input.back();
+        } else if (this._ch) {
+          this.print_string(this._ch + this.eatString(')'));
+          if (parenLevel) {
+            parenLevel--;
+            this.outdent();
+          }
+        }
+      } else {
+        var space_needed = false;
+        if (this._input.lookBack("with")) {
+          // look back is not an accurate solution, we need tokens to confirm without whitespaces
+          space_needed = true;
+        }
+        this.preserveSingleSpace(isAfterSpace || space_needed);
+        this.print_string(this._ch);
+
+        // handle scss/sass map
+        if (insidePropertyValue && previous_ch === "$" && this._options.selector_separator_newline) {
+          this._output.add_new_line();
+          insideScssMap = true;
+        } else {
+          this.eatWhitespace();
+          parenLevel++;
+          this.indent();
+        }
+      }
+    } else if (this._ch === ')') {
+      if (parenLevel) {
+        parenLevel--;
+        this.outdent();
+      }
+      if (insideScssMap && this._input.peek() === ";" && this._options.selector_separator_newline) {
+        insideScssMap = false;
+        this.outdent();
+        this._output.add_new_line();
+      }
+      this.print_string(this._ch);
+    } else if (this._ch === ',') {
+      this.print_string(this._ch);
+      this.eatWhitespace(true);
+      if (this._options.selector_separator_newline && (!insidePropertyValue || insideScssMap) && parenLevel === 0 && !insideNonNestedAtRule) {
+        this._output.add_new_line();
+      } else {
+        this._output.space_before_token = true;
+      }
+    } else if ((this._ch === '>' || this._ch === '+' || this._ch === '~') && !insidePropertyValue && parenLevel === 0) {
+      //handle combinator spacing
+      if (this._options.space_around_combinator) {
+        this._output.space_before_token = true;
+        this.print_string(this._ch);
+        this._output.space_before_token = true;
+      } else {
+        this.print_string(this._ch);
+        this.eatWhitespace();
+        // squash extra whitespace
+        if (this._ch && whitespaceChar.test(this._ch)) {
+          this._ch = '';
+        }
+      }
+    } else if (this._ch === ']') {
+      this.print_string(this._ch);
+    } else if (this._ch === '[') {
+      this.preserveSingleSpace(isAfterSpace);
+      this.print_string(this._ch);
+    } else if (this._ch === '=') { // no whitespace before or after
+      this.eatWhitespace();
+      this.print_string('=');
+      if (whitespaceChar.test(this._ch)) {
+        this._ch = '';
+      }
+    } else if (this._ch === '!' && !this._input.lookBack("\\")) { // !important
+      this._output.space_before_token = true;
+      this.print_string(this._ch);
+    } else {
+      var preserveAfterSpace = previous_ch === '"' || previous_ch === '\'';
+      this.preserveSingleSpace(preserveAfterSpace || isAfterSpace);
+      this.print_string(this._ch);
+
+      if (!this._output.just_added_newline() && this._input.peek() === '\n' && insideNonSemiColonValues) {
+        this._output.add_new_line();
+      }
+    }
+  }
+
+  var sweetCode = this._output.get_code(eol);
+
+  return sweetCode;
+};
+
+module.exports.Beautifier = Beautifier;
+
+
+/***/ }),
+/* 17 */
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+/*jshint node:true */
+/*
+
+  The MIT License (MIT)
+
+  Copyright (c) 2007-2018 Einar Lielmanis, Liam Newman, and contributors.
+
+  Permission is hereby granted, free of charge, to any person
+  obtaining a copy of this software and associated documentation files
+  (the "Software"), to deal in the Software without restriction,
+  including without limitation the rights to use, copy, modify, merge,
+  publish, distribute, sublicense, and/or sell copies of the Software,
+  and to permit persons to whom the Software is furnished to do so,
+  subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be
+  included in all copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+  BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+  ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+  CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+*/
+
+
+
+var BaseOptions = (__webpack_require__(6).Options);
+
+function Options(options) {
+  BaseOptions.call(this, options, 'css');
+
+  this.selector_separator_newline = this._get_boolean('selector_separator_newline', true);
+  this.newline_between_rules = this._get_boolean('newline_between_rules', true);
+  var space_around_selector_separator = this._get_boolean('space_around_selector_separator');
+  this.space_around_combinator = this._get_boolean('space_around_combinator') || space_around_selector_separator;
+
+  var brace_style_split = this._get_selection_list('brace_style', ['collapse', 'expand', 'end-expand', 'none', 'preserve-inline']);
+  this.brace_style = 'collapse';
+  for (var bs = 0; bs < brace_style_split.length; bs++) {
+    if (brace_style_split[bs] !== 'expand') {
+      // default to collapse, as only collapse|expand is implemented for now
+      this.brace_style = 'collapse';
+    } else {
+      this.brace_style = brace_style_split[bs];
+    }
+  }
+}
+Options.prototype = new BaseOptions();
+
+
+
+module.exports.Options = Options;
+
+
+/***/ })
+/******/ 	]);
+/************************************************************************/
+/******/ 	// The module cache
+/******/ 	var __webpack_module_cache__ = {};
+/******/ 	
+/******/ 	// The require function
+/******/ 	function __webpack_require__(moduleId) {
+/******/ 		// Check if module is in cache
+/******/ 		var cachedModule = __webpack_module_cache__[moduleId];
+/******/ 		if (cachedModule !== undefined) {
+/******/ 			return cachedModule.exports;
+/******/ 		}
+/******/ 		// Create a new module (and put it into the cache)
+/******/ 		var module = __webpack_module_cache__[moduleId] = {
+/******/ 			// no module.id needed
+/******/ 			// no module.loaded needed
+/******/ 			exports: {}
+/******/ 		};
+/******/ 	
+/******/ 		// Execute the module function
+/******/ 		__webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+/******/ 	
+/******/ 		// Return the exports of the module
+/******/ 		return module.exports;
+/******/ 	}
+/******/ 	
+/************************************************************************/
+/******/ 	
+/******/ 	// startup
+/******/ 	// Load entry module and return exports
+/******/ 	// This entry module is referenced by other modules so it can't be inlined
+/******/ 	var __webpack_exports__ = __webpack_require__(15);
+/******/ 	legacy_beautify_css = __webpack_exports__;
+/******/ 	
+/******/ })()
+;
+var css_beautify = legacy_beautify_css;
+/* Footer */
+if (typeof define === "function" && define.amd) {
+    // Add support for AMD ( https://github.com/amdjs/amdjs-api/wiki/AMD#defineamd-property- )
+    define([], function() {
+        return {
+            css_beautify: css_beautify
+        };
+    });
+} else if (typeof exports !== "undefined") {
+    // Add support for CommonJS. Just put this file somewhere on your require.paths
+    // and you will be able to `var html_beautify = require("beautify").html_beautify`.
+    exports.css_beautify = css_beautify;
+} else if (typeof window !== "undefined") {
+    // If we're running a web page and don't have either of the above, add our one global
+    window.css_beautify = css_beautify;
+} else if (typeof global !== "undefined") {
+    // If we don't even have window, try global.
+    global.css_beautify = css_beautify;
+}
+
+}());

Java开发环境安装/eclipse-jee-2024-06-R-win32-x86_64/eclipse/plugins/org.eclipse.wildwebdeveloper_1.2.2.202405280856/node_modules/volar-service-html/node_modules/vscode-html-languageservice/lib/umd/beautify/beautify.js

@@ -1,3 +1,25 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:07c96eca8fa5d2897a1ada7d5a166b7aa647d581b3bf50cb2e3e4cba8d9574b7
-size 1077
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.js_beautify = void 0;
+    /*---------------------------------------------------------------------------------------------
+     *  Copyright (c) Microsoft Corporation. All rights reserved.
+     *  Licensed under the MIT License. See License.txt in the project root for license information.
+     *--------------------------------------------------------------------------------------------*/
+    /*
+     * Mock for the JS formatter. Ignore formatting of JS content in HTML.
+     */
+    function js_beautify(js_source_text, options) {
+        // no formatting
+        return js_source_text;
+    }
+    exports.js_beautify = js_beautify;
+});

Java开发环境安装/eclipse-jee-2024-06-R-win32-x86_64/eclipse/plugins/org.eclipse.wildwebdeveloper_1.2.2.202405280856/node_modules/volar-service-html/node_modules/vscode-html-languageservice/lib/umd/htmlLanguageService.d.ts

@@ -1,3 +1,30 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:8044ec1977fdea7750c43309c60f2ee8aeab66616631a13e811559370bed57de
-size 3018
+import { Scanner, HTMLDocument, CompletionConfiguration, ICompletionParticipant, HTMLFormatConfiguration, DocumentContext, DocumentSymbol, IHTMLDataProvider, HTMLDataV1, LanguageServiceOptions, TextDocument, SelectionRange, WorkspaceEdit, Position, CompletionList, Hover, Range, SymbolInformation, TextEdit, DocumentHighlight, DocumentLink, FoldingRange, HoverSettings } from './htmlLanguageTypes';
+export * from './htmlLanguageTypes';
+export interface LanguageService {
+    setDataProviders(useDefaultDataProvider: boolean, customDataProviders: IHTMLDataProvider[]): void;
+    createScanner(input: string, initialOffset?: number): Scanner;
+    parseHTMLDocument(document: TextDocument): HTMLDocument;
+    findDocumentHighlights(document: TextDocument, position: Position, htmlDocument: HTMLDocument): DocumentHighlight[];
+    doComplete(document: TextDocument, position: Position, htmlDocument: HTMLDocument, options?: CompletionConfiguration): CompletionList;
+    doComplete2(document: TextDocument, position: Position, htmlDocument: HTMLDocument, documentContext: DocumentContext, options?: CompletionConfiguration): Promise<CompletionList>;
+    setCompletionParticipants(registeredCompletionParticipants: ICompletionParticipant[]): void;
+    doHover(document: TextDocument, position: Position, htmlDocument: HTMLDocument, options?: HoverSettings): Hover | null;
+    format(document: TextDocument, range: Range | undefined, options: HTMLFormatConfiguration): TextEdit[];
+    findDocumentLinks(document: TextDocument, documentContext: DocumentContext): DocumentLink[];
+    findDocumentSymbols(document: TextDocument, htmlDocument: HTMLDocument): SymbolInformation[];
+    findDocumentSymbols2(document: TextDocument, htmlDocument: HTMLDocument): DocumentSymbol[];
+    doQuoteComplete(document: TextDocument, position: Position, htmlDocument: HTMLDocument, options?: CompletionConfiguration): string | null;
+    doTagComplete(document: TextDocument, position: Position, htmlDocument: HTMLDocument): string | null;
+    getFoldingRanges(document: TextDocument, context?: {
+        rangeLimit?: number;
+    }): FoldingRange[];
+    getSelectionRanges(document: TextDocument, positions: Position[]): SelectionRange[];
+    doRename(document: TextDocument, position: Position, newName: string, htmlDocument: HTMLDocument): WorkspaceEdit | null;
+    findMatchingTagPosition(document: TextDocument, position: Position, htmlDocument: HTMLDocument): Position | null;
+    /** Deprecated, Use findLinkedEditingRanges instead */
+    findOnTypeRenameRanges(document: TextDocument, position: Position, htmlDocument: HTMLDocument): Range[] | null;
+    findLinkedEditingRanges(document: TextDocument, position: Position, htmlDocument: HTMLDocument): Range[] | null;
+}
+export declare function getLanguageService(options?: LanguageServiceOptions): LanguageService;
+export declare function newHTMLDataProvider(id: string, customData: HTMLDataV1): IHTMLDataProvider;
+export declare function getDefaultHTMLDataProvider(): IHTMLDataProvider;

Java开发环境安装/eclipse-jee-2024-06-R-win32-x86_64/eclipse/plugins/org.eclipse.wildwebdeveloper_1.2.2.202405280856/node_modules/volar-service-html/node_modules/vscode-html-languageservice/lib/umd/htmlLanguageService.js

@@ -1,3 +1,89 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:a9e331eba24eb799bdce5c32664fdb685945c04b80d516f933ecd9bb00ae78ec
-size 5840
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "./parser/htmlScanner", "./parser/htmlParser", "./services/htmlCompletion", "./services/htmlHover", "./services/htmlFormatter", "./services/htmlLinks", "./services/htmlHighlighting", "./services/htmlSymbolsProvider", "./services/htmlRename", "./services/htmlMatchingTagPosition", "./services/htmlLinkedEditing", "./services/htmlFolding", "./services/htmlSelectionRange", "./languageFacts/dataProvider", "./languageFacts/dataManager", "./languageFacts/data/webCustomData", "./htmlLanguageTypes"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.getDefaultHTMLDataProvider = exports.newHTMLDataProvider = exports.getLanguageService = void 0;
+    const htmlScanner_1 = require("./parser/htmlScanner");
+    const htmlParser_1 = require("./parser/htmlParser");
+    const htmlCompletion_1 = require("./services/htmlCompletion");
+    const htmlHover_1 = require("./services/htmlHover");
+    const htmlFormatter_1 = require("./services/htmlFormatter");
+    const htmlLinks_1 = require("./services/htmlLinks");
+    const htmlHighlighting_1 = require("./services/htmlHighlighting");
+    const htmlSymbolsProvider_1 = require("./services/htmlSymbolsProvider");
+    const htmlRename_1 = require("./services/htmlRename");
+    const htmlMatchingTagPosition_1 = require("./services/htmlMatchingTagPosition");
+    const htmlLinkedEditing_1 = require("./services/htmlLinkedEditing");
+    const htmlFolding_1 = require("./services/htmlFolding");
+    const htmlSelectionRange_1 = require("./services/htmlSelectionRange");
+    const dataProvider_1 = require("./languageFacts/dataProvider");
+    const dataManager_1 = require("./languageFacts/dataManager");
+    const webCustomData_1 = require("./languageFacts/data/webCustomData");
+    __exportStar(require("./htmlLanguageTypes"), exports);
+    const defaultLanguageServiceOptions = {};
+    function getLanguageService(options = defaultLanguageServiceOptions) {
+        const dataManager = new dataManager_1.HTMLDataManager(options);
+        const htmlHover = new htmlHover_1.HTMLHover(options, dataManager);
+        const htmlCompletion = new htmlCompletion_1.HTMLCompletion(options, dataManager);
+        const htmlParser = new htmlParser_1.HTMLParser(dataManager);
+        const htmlSelectionRange = new htmlSelectionRange_1.HTMLSelectionRange(htmlParser);
+        const htmlFolding = new htmlFolding_1.HTMLFolding(dataManager);
+        const htmlDocumentLinks = new htmlLinks_1.HTMLDocumentLinks(dataManager);
+        return {
+            setDataProviders: dataManager.setDataProviders.bind(dataManager),
+            createScanner: htmlScanner_1.createScanner,
+            parseHTMLDocument: htmlParser.parseDocument.bind(htmlParser),
+            doComplete: htmlCompletion.doComplete.bind(htmlCompletion),
+            doComplete2: htmlCompletion.doComplete2.bind(htmlCompletion),
+            setCompletionParticipants: htmlCompletion.setCompletionParticipants.bind(htmlCompletion),
+            doHover: htmlHover.doHover.bind(htmlHover),
+            format: htmlFormatter_1.format,
+            findDocumentHighlights: htmlHighlighting_1.findDocumentHighlights,
+            findDocumentLinks: htmlDocumentLinks.findDocumentLinks.bind(htmlDocumentLinks),
+            findDocumentSymbols: htmlSymbolsProvider_1.findDocumentSymbols,
+            findDocumentSymbols2: htmlSymbolsProvider_1.findDocumentSymbols2,
+            getFoldingRanges: htmlFolding.getFoldingRanges.bind(htmlFolding),
+            getSelectionRanges: htmlSelectionRange.getSelectionRanges.bind(htmlSelectionRange),
+            doQuoteComplete: htmlCompletion.doQuoteComplete.bind(htmlCompletion),
+            doTagComplete: htmlCompletion.doTagComplete.bind(htmlCompletion),
+            doRename: htmlRename_1.doRename,
+            findMatchingTagPosition: htmlMatchingTagPosition_1.findMatchingTagPosition,
+            findOnTypeRenameRanges: htmlLinkedEditing_1.findLinkedEditingRanges,
+            findLinkedEditingRanges: htmlLinkedEditing_1.findLinkedEditingRanges
+        };
+    }
+    exports.getLanguageService = getLanguageService;
+    function newHTMLDataProvider(id, customData) {
+        return new dataProvider_1.HTMLDataProvider(id, customData);
+    }
+    exports.newHTMLDataProvider = newHTMLDataProvider;
+    function getDefaultHTMLDataProvider() {
+        return newHTMLDataProvider('default', webCustomData_1.htmlData);
+    }
+    exports.getDefaultHTMLDataProvider = getDefaultHTMLDataProvider;
+});

Java开发环境安装/eclipse-jee-2024-06-R-win32-x86_64/eclipse/plugins/org.eclipse.wildwebdeveloper_1.2.2.202405280856/node_modules/volar-service-html/node_modules/vscode-html-languageservice/lib/umd/htmlLanguageTypes.d.ts

@@ -1,3 +1,256 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:7f5b0f6aad8f3ff0736fa295c721b27f16d974f511221d8b6954cb2a91d49970
-size 8083
+import { Position, Range, Location, MarkupContent, MarkupKind, MarkedString, DocumentUri, SelectionRange, WorkspaceEdit, CompletionList, CompletionItemKind, CompletionItem, CompletionItemTag, InsertTextMode, Command, SymbolInformation, DocumentSymbol, SymbolKind, Hover, TextEdit, InsertReplaceEdit, InsertTextFormat, DocumentHighlight, DocumentHighlightKind, DocumentLink, FoldingRange, FoldingRangeKind, SignatureHelp, Definition, Diagnostic, FormattingOptions, Color, ColorInformation, ColorPresentation } from 'vscode-languageserver-types';
+import { TextDocument } from 'vscode-languageserver-textdocument';
+export { TextDocument, Position, Range, Location, MarkupContent, MarkupKind, MarkedString, DocumentUri, SelectionRange, WorkspaceEdit, CompletionList, CompletionItemKind, CompletionItem, CompletionItemTag, InsertTextMode, Command, SymbolInformation, DocumentSymbol, SymbolKind, Hover, TextEdit, InsertReplaceEdit, InsertTextFormat, DocumentHighlight, DocumentHighlightKind, DocumentLink, FoldingRange, FoldingRangeKind, SignatureHelp, Definition, Diagnostic, FormattingOptions, Color, ColorInformation, ColorPresentation };
+export interface HTMLFormatConfiguration {
+    tabSize?: number;
+    insertSpaces?: boolean;
+    indentEmptyLines?: boolean;
+    wrapLineLength?: number;
+    unformatted?: string;
+    contentUnformatted?: string;
+    indentInnerHtml?: boolean;
+    wrapAttributes?: 'auto' | 'force' | 'force-aligned' | 'force-expand-multiline' | 'aligned-multiple' | 'preserve' | 'preserve-aligned';
+    wrapAttributesIndentSize?: number;
+    preserveNewLines?: boolean;
+    maxPreserveNewLines?: number;
+    indentHandlebars?: boolean;
+    endWithNewline?: boolean;
+    extraLiners?: string;
+    indentScripts?: 'keep' | 'separate' | 'normal';
+    templating?: ('auto' | 'none' | 'angular' | 'django' | 'erb' | 'handlebars' | 'php' | 'smarty')[] | boolean;
+    unformattedContentDelimiter?: string;
+}
+export interface HoverSettings {
+    documentation?: boolean;
+    references?: boolean;
+}
+export interface CompletionConfiguration {
+    [provider: string]: boolean | undefined | string;
+    hideAutoCompleteProposals?: boolean;
+    attributeDefaultValue?: 'empty' | 'singlequotes' | 'doublequotes';
+}
+export interface Node {
+    tag: string | undefined;
+    start: number;
+    startTagEnd: number | undefined;
+    end: number;
+    endTagStart: number | undefined;
+    children: Node[];
+    parent?: Node;
+    attributes?: {
+        [name: string]: string | null;
+    } | undefined;
+}
+export declare enum TokenType {
+    StartCommentTag = 0,
+    Comment = 1,
+    EndCommentTag = 2,
+    StartTagOpen = 3,
+    StartTagClose = 4,
+    StartTagSelfClose = 5,
+    StartTag = 6,
+    EndTagOpen = 7,
+    EndTagClose = 8,
+    EndTag = 9,
+    DelimiterAssign = 10,
+    AttributeName = 11,
+    AttributeValue = 12,
+    StartDoctypeTag = 13,
+    Doctype = 14,
+    EndDoctypeTag = 15,
+    Content = 16,
+    Whitespace = 17,
+    Unknown = 18,
+    Script = 19,
+    Styles = 20,
+    EOS = 21
+}
+export declare enum ScannerState {
+    WithinContent = 0,
+    AfterOpeningStartTag = 1,
+    AfterOpeningEndTag = 2,
+    WithinDoctype = 3,
+    WithinTag = 4,
+    WithinEndTag = 5,
+    WithinComment = 6,
+    WithinScriptContent = 7,
+    WithinStyleContent = 8,
+    AfterAttributeName = 9,
+    BeforeAttributeValue = 10
+}
+export interface Scanner {
+    scan(): TokenType;
+    getTokenType(): TokenType;
+    getTokenOffset(): number;
+    getTokenLength(): number;
+    getTokenEnd(): number;
+    getTokenText(): string;
+    getTokenError(): string | undefined;
+    getScannerState(): ScannerState;
+}
+export declare type HTMLDocument = {
+    roots: Node[];
+    findNodeBefore(offset: number): Node;
+    findNodeAt(offset: number): Node;
+};
+export interface DocumentContext {
+    resolveReference(ref: string, base: string): string | undefined;
+}
+export interface HtmlAttributeValueContext {
+    document: TextDocument;
+    position: Position;
+    tag: string;
+    attribute: string;
+    value: string;
+    range: Range;
+}
+export interface HtmlContentContext {
+    document: TextDocument;
+    position: Position;
+}
+export interface ICompletionParticipant {
+    onHtmlAttributeValue?: (context: HtmlAttributeValueContext) => void;
+    onHtmlContent?: (context: HtmlContentContext) => void;
+}
+export interface IReference {
+    name: string;
+    url: string;
+}
+export interface ITagData {
+    name: string;
+    description?: string | MarkupContent;
+    attributes: IAttributeData[];
+    references?: IReference[];
+    void?: boolean;
+}
+export interface IAttributeData {
+    name: string;
+    description?: string | MarkupContent;
+    valueSet?: string;
+    values?: IValueData[];
+    references?: IReference[];
+}
+export interface IValueData {
+    name: string;
+    description?: string | MarkupContent;
+    references?: IReference[];
+}
+export interface IValueSet {
+    name: string;
+    values: IValueData[];
+}
+export interface HTMLDataV1 {
+    version: 1 | 1.1;
+    tags?: ITagData[];
+    globalAttributes?: IAttributeData[];
+    valueSets?: IValueSet[];
+}
+export interface IHTMLDataProvider {
+    getId(): string;
+    isApplicable(languageId: string): boolean;
+    provideTags(): ITagData[];
+    provideAttributes(tag: string): IAttributeData[];
+    provideValues(tag: string, attribute: string): IValueData[];
+}
+/**
+ * Describes what LSP capabilities the client supports
+ */
+export interface ClientCapabilities {
+    /**
+     * The text document client capabilities
+     */
+    textDocument?: {
+        /**
+         * Capabilities specific to completions.
+         */
+        completion?: {
+            /**
+             * The client supports the following `CompletionItem` specific
+             * capabilities.
+             */
+            completionItem?: {
+                /**
+                 * Client supports the follow content formats for the documentation
+                 * property. The order describes the preferred format of the client.
+                 */
+                documentationFormat?: MarkupKind[];
+            };
+        };
+        /**
+         * Capabilities specific to hovers.
+         */
+        hover?: {
+            /**
+             * Client supports the follow content formats for the content
+             * property. The order describes the preferred format of the client.
+             */
+            contentFormat?: MarkupKind[];
+        };
+    };
+}
+export declare namespace ClientCapabilities {
+    const LATEST: ClientCapabilities;
+}
+export interface LanguageServiceOptions {
+    /**
+     * Unless set to false, the default HTML data provider will be used
+     * along with the providers from customDataProviders.
+     * Defaults to true.
+     */
+    useDefaultDataProvider?: boolean;
+    /**
+     * Provide data that could enhance the service's understanding of
+     * HTML tag / attribute / attribute-value
+     */
+    customDataProviders?: IHTMLDataProvider[];
+    /**
+     * Abstract file system access away from the service.
+     * Used for path completion, etc.
+     */
+    fileSystemProvider?: FileSystemProvider;
+    /**
+     * Describes the LSP capabilities the client supports.
+     */
+    clientCapabilities?: ClientCapabilities;
+}
+export declare enum FileType {
+    /**
+     * The file type is unknown.
+     */
+    Unknown = 0,
+    /**
+     * A regular file.
+     */
+    File = 1,
+    /**
+     * A directory.
+     */
+    Directory = 2,
+    /**
+     * A symbolic link to a file.
+     */
+    SymbolicLink = 64
+}
+export interface FileStat {
+    /**
+     * The type of the file, e.g. is a regular file, a directory, or symbolic link
+     * to a file.
+     */
+    type: FileType;
+    /**
+     * The creation timestamp in milliseconds elapsed since January 1, 1970 00:00:00 UTC.
+     */
+    ctime: number;
+    /**
+     * The modification timestamp in milliseconds elapsed since January 1, 1970 00:00:00 UTC.
+     */
+    mtime: number;
+    /**
+     * The size in bytes.
+     */
+    size: number;
+}
+export interface FileSystemProvider {
+    stat(uri: DocumentUri): Promise<FileStat>;
+    readDirectory?(uri: DocumentUri): Promise<[string, FileType][]>;
+}

Java开发环境安装/eclipse-jee-2024-06-R-win32-x86_64/eclipse/plugins/org.eclipse.wildwebdeveloper_1.2.2.202405280856/node_modules/volar-service-html/node_modules/vscode-html-languageservice/lib/umd/htmlLanguageTypes.js

@@ -1,3 +1,125 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:4b984ec4b0d2d71935b10296dc97994697c1ae76b2d4ccafdec5acc52b1e9141
-size 10584
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "vscode-languageserver-types", "vscode-languageserver-textdocument"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.FileType = exports.ClientCapabilities = exports.ScannerState = exports.TokenType = exports.ColorPresentation = exports.ColorInformation = exports.Color = exports.FormattingOptions = exports.Diagnostic = exports.FoldingRangeKind = exports.FoldingRange = exports.DocumentLink = exports.DocumentHighlightKind = exports.DocumentHighlight = exports.InsertTextFormat = exports.InsertReplaceEdit = exports.TextEdit = exports.Hover = exports.SymbolKind = exports.DocumentSymbol = exports.SymbolInformation = exports.Command = exports.InsertTextMode = exports.CompletionItemTag = exports.CompletionItem = exports.CompletionItemKind = exports.CompletionList = exports.WorkspaceEdit = exports.SelectionRange = exports.DocumentUri = exports.MarkedString = exports.MarkupKind = exports.MarkupContent = exports.Location = exports.Range = exports.Position = exports.TextDocument = void 0;
+    const vscode_languageserver_types_1 = require("vscode-languageserver-types");
+    Object.defineProperty(exports, "Position", { enumerable: true, get: function () { return vscode_languageserver_types_1.Position; } });
+    Object.defineProperty(exports, "Range", { enumerable: true, get: function () { return vscode_languageserver_types_1.Range; } });
+    Object.defineProperty(exports, "Location", { enumerable: true, get: function () { return vscode_languageserver_types_1.Location; } });
+    Object.defineProperty(exports, "MarkupContent", { enumerable: true, get: function () { return vscode_languageserver_types_1.MarkupContent; } });
+    Object.defineProperty(exports, "MarkupKind", { enumerable: true, get: function () { return vscode_languageserver_types_1.MarkupKind; } });
+    Object.defineProperty(exports, "MarkedString", { enumerable: true, get: function () { return vscode_languageserver_types_1.MarkedString; } });
+    Object.defineProperty(exports, "DocumentUri", { enumerable: true, get: function () { return vscode_languageserver_types_1.DocumentUri; } });
+    Object.defineProperty(exports, "SelectionRange", { enumerable: true, get: function () { return vscode_languageserver_types_1.SelectionRange; } });
+    Object.defineProperty(exports, "WorkspaceEdit", { enumerable: true, get: function () { return vscode_languageserver_types_1.WorkspaceEdit; } });
+    Object.defineProperty(exports, "CompletionList", { enumerable: true, get: function () { return vscode_languageserver_types_1.CompletionList; } });
+    Object.defineProperty(exports, "CompletionItemKind", { enumerable: true, get: function () { return vscode_languageserver_types_1.CompletionItemKind; } });
+    Object.defineProperty(exports, "CompletionItem", { enumerable: true, get: function () { return vscode_languageserver_types_1.CompletionItem; } });
+    Object.defineProperty(exports, "CompletionItemTag", { enumerable: true, get: function () { return vscode_languageserver_types_1.CompletionItemTag; } });
+    Object.defineProperty(exports, "InsertTextMode", { enumerable: true, get: function () { return vscode_languageserver_types_1.InsertTextMode; } });
+    Object.defineProperty(exports, "Command", { enumerable: true, get: function () { return vscode_languageserver_types_1.Command; } });
+    Object.defineProperty(exports, "SymbolInformation", { enumerable: true, get: function () { return vscode_languageserver_types_1.SymbolInformation; } });
+    Object.defineProperty(exports, "DocumentSymbol", { enumerable: true, get: function () { return vscode_languageserver_types_1.DocumentSymbol; } });
+    Object.defineProperty(exports, "SymbolKind", { enumerable: true, get: function () { return vscode_languageserver_types_1.SymbolKind; } });
+    Object.defineProperty(exports, "Hover", { enumerable: true, get: function () { return vscode_languageserver_types_1.Hover; } });
+    Object.defineProperty(exports, "TextEdit", { enumerable: true, get: function () { return vscode_languageserver_types_1.TextEdit; } });
+    Object.defineProperty(exports, "InsertReplaceEdit", { enumerable: true, get: function () { return vscode_languageserver_types_1.InsertReplaceEdit; } });
+    Object.defineProperty(exports, "InsertTextFormat", { enumerable: true, get: function () { return vscode_languageserver_types_1.InsertTextFormat; } });
+    Object.defineProperty(exports, "DocumentHighlight", { enumerable: true, get: function () { return vscode_languageserver_types_1.DocumentHighlight; } });
+    Object.defineProperty(exports, "DocumentHighlightKind", { enumerable: true, get: function () { return vscode_languageserver_types_1.DocumentHighlightKind; } });
+    Object.defineProperty(exports, "DocumentLink", { enumerable: true, get: function () { return vscode_languageserver_types_1.DocumentLink; } });
+    Object.defineProperty(exports, "FoldingRange", { enumerable: true, get: function () { return vscode_languageserver_types_1.FoldingRange; } });
+    Object.defineProperty(exports, "FoldingRangeKind", { enumerable: true, get: function () { return vscode_languageserver_types_1.FoldingRangeKind; } });
+    Object.defineProperty(exports, "Diagnostic", { enumerable: true, get: function () { return vscode_languageserver_types_1.Diagnostic; } });
+    Object.defineProperty(exports, "FormattingOptions", { enumerable: true, get: function () { return vscode_languageserver_types_1.FormattingOptions; } });
+    Object.defineProperty(exports, "Color", { enumerable: true, get: function () { return vscode_languageserver_types_1.Color; } });
+    Object.defineProperty(exports, "ColorInformation", { enumerable: true, get: function () { return vscode_languageserver_types_1.ColorInformation; } });
+    Object.defineProperty(exports, "ColorPresentation", { enumerable: true, get: function () { return vscode_languageserver_types_1.ColorPresentation; } });
+    const vscode_languageserver_textdocument_1 = require("vscode-languageserver-textdocument");
+    Object.defineProperty(exports, "TextDocument", { enumerable: true, get: function () { return vscode_languageserver_textdocument_1.TextDocument; } });
+    var TokenType;
+    (function (TokenType) {
+        TokenType[TokenType["StartCommentTag"] = 0] = "StartCommentTag";
+        TokenType[TokenType["Comment"] = 1] = "Comment";
+        TokenType[TokenType["EndCommentTag"] = 2] = "EndCommentTag";
+        TokenType[TokenType["StartTagOpen"] = 3] = "StartTagOpen";
+        TokenType[TokenType["StartTagClose"] = 4] = "StartTagClose";
+        TokenType[TokenType["StartTagSelfClose"] = 5] = "StartTagSelfClose";
+        TokenType[TokenType["StartTag"] = 6] = "StartTag";
+        TokenType[TokenType["EndTagOpen"] = 7] = "EndTagOpen";
+        TokenType[TokenType["EndTagClose"] = 8] = "EndTagClose";
+        TokenType[TokenType["EndTag"] = 9] = "EndTag";
+        TokenType[TokenType["DelimiterAssign"] = 10] = "DelimiterAssign";
+        TokenType[TokenType["AttributeName"] = 11] = "AttributeName";
+        TokenType[TokenType["AttributeValue"] = 12] = "AttributeValue";
+        TokenType[TokenType["StartDoctypeTag"] = 13] = "StartDoctypeTag";
+        TokenType[TokenType["Doctype"] = 14] = "Doctype";
+        TokenType[TokenType["EndDoctypeTag"] = 15] = "EndDoctypeTag";
+        TokenType[TokenType["Content"] = 16] = "Content";
+        TokenType[TokenType["Whitespace"] = 17] = "Whitespace";
+        TokenType[TokenType["Unknown"] = 18] = "Unknown";
+        TokenType[TokenType["Script"] = 19] = "Script";
+        TokenType[TokenType["Styles"] = 20] = "Styles";
+        TokenType[TokenType["EOS"] = 21] = "EOS";
+    })(TokenType || (exports.TokenType = TokenType = {}));
+    var ScannerState;
+    (function (ScannerState) {
+        ScannerState[ScannerState["WithinContent"] = 0] = "WithinContent";
+        ScannerState[ScannerState["AfterOpeningStartTag"] = 1] = "AfterOpeningStartTag";
+        ScannerState[ScannerState["AfterOpeningEndTag"] = 2] = "AfterOpeningEndTag";
+        ScannerState[ScannerState["WithinDoctype"] = 3] = "WithinDoctype";
+        ScannerState[ScannerState["WithinTag"] = 4] = "WithinTag";
+        ScannerState[ScannerState["WithinEndTag"] = 5] = "WithinEndTag";
+        ScannerState[ScannerState["WithinComment"] = 6] = "WithinComment";
+        ScannerState[ScannerState["WithinScriptContent"] = 7] = "WithinScriptContent";
+        ScannerState[ScannerState["WithinStyleContent"] = 8] = "WithinStyleContent";
+        ScannerState[ScannerState["AfterAttributeName"] = 9] = "AfterAttributeName";
+        ScannerState[ScannerState["BeforeAttributeValue"] = 10] = "BeforeAttributeValue";
+    })(ScannerState || (exports.ScannerState = ScannerState = {}));
+    var ClientCapabilities;
+    (function (ClientCapabilities) {
+        ClientCapabilities.LATEST = {
+            textDocument: {
+                completion: {
+                    completionItem: {
+                        documentationFormat: [vscode_languageserver_types_1.MarkupKind.Markdown, vscode_languageserver_types_1.MarkupKind.PlainText]
+                    }
+                },
+                hover: {
+                    contentFormat: [vscode_languageserver_types_1.MarkupKind.Markdown, vscode_languageserver_types_1.MarkupKind.PlainText]
+                }
+            }
+        };
+    })(ClientCapabilities || (exports.ClientCapabilities = ClientCapabilities = {}));
+    var FileType;
+    (function (FileType) {
+        /**
+         * The file type is unknown.
+         */
+        FileType[FileType["Unknown"] = 0] = "Unknown";
+        /**
+         * A regular file.
+         */
+        FileType[FileType["File"] = 1] = "File";
+        /**
+         * A directory.
+         */
+        FileType[FileType["Directory"] = 2] = "Directory";
+        /**
+         * A symbolic link to a file.
+         */
+        FileType[FileType["SymbolicLink"] = 64] = "SymbolicLink";
+    })(FileType || (exports.FileType = FileType = {}));
+});

Java开发环境安装/eclipse-jee-2024-06-R-win32-x86_64/eclipse/plugins/org.eclipse.wildwebdeveloper_1.2.2.202405280856/node_modules/volar-service-html/node_modules/vscode-html-languageservice/lib/umd/languageFacts/data/webCustomData.d.ts

@@ -1,3 +1,2 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:4915df6340f6cd0cd6aa8765179ae2e0fcee11a6b1936d31638ddba74226f2fe
-size 97
+import { HTMLDataV1 } from '../../htmlLanguageTypes';
+export declare const htmlData: HTMLDataV1;

Java开发环境安装/eclipse-jee-2024-06-R-win32-x86_64/eclipse/plugins/org.eclipse.wildwebdeveloper_1.2.2.202405280856/node_modules/volar-service-html/node_modules/vscode-html-languageservice/lib/umd/languageFacts/dataManager.js

@@ -1,3 +1,91 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:732dd4dfebda59c0956ecc858fab0772674f93da861cc4a1cdca5c977569f3d0
-size 3525
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "./dataProvider", "./data/webCustomData", "../utils/arrays"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.HTMLDataManager = void 0;
+    const dataProvider_1 = require("./dataProvider");
+    const webCustomData_1 = require("./data/webCustomData");
+    const arrays = require("../utils/arrays");
+    class HTMLDataManager {
+        constructor(options) {
+            this.dataProviders = [];
+            this.setDataProviders(options.useDefaultDataProvider !== false, options.customDataProviders || []);
+        }
+        setDataProviders(builtIn, providers) {
+            this.dataProviders = [];
+            if (builtIn) {
+                this.dataProviders.push(new dataProvider_1.HTMLDataProvider('html5', webCustomData_1.htmlData));
+            }
+            this.dataProviders.push(...providers);
+        }
+        getDataProviders() {
+            return this.dataProviders;
+        }
+        isVoidElement(e, voidElements) {
+            return !!e && arrays.binarySearch(voidElements, e.toLowerCase(), (s1, s2) => s1.localeCompare(s2)) >= 0;
+        }
+        getVoidElements(languageOrProviders) {
+            const dataProviders = Array.isArray(languageOrProviders) ? languageOrProviders : this.getDataProviders().filter(p => p.isApplicable(languageOrProviders));
+            const voidTags = [];
+            dataProviders.forEach((provider) => {
+                provider.provideTags().filter(tag => tag.void).forEach(tag => voidTags.push(tag.name));
+            });
+            return voidTags.sort();
+        }
+        isPathAttribute(tag, attr) {
+            // should eventually come from custom data
+            if (attr === 'src' || attr === 'href') {
+                return true;
+            }
+            const a = PATH_TAG_AND_ATTR[tag];
+            if (a) {
+                if (typeof a === 'string') {
+                    return a === attr;
+                }
+                else {
+                    return a.indexOf(attr) !== -1;
+                }
+            }
+            return false;
+        }
+    }
+    exports.HTMLDataManager = HTMLDataManager;
+    // Selected from https://stackoverflow.com/a/2725168/1780148
+    const PATH_TAG_AND_ATTR = {
+        // HTML 4
+        a: 'href',
+        area: 'href',
+        body: 'background',
+        blockquote: 'cite',
+        del: 'cite',
+        form: 'action',
+        frame: ['src', 'longdesc'],
+        img: ['src', 'longdesc'],
+        ins: 'cite',
+        link: 'href',
+        object: 'data',
+        q: 'cite',
+        script: 'src',
+        // HTML 5
+        audio: 'src',
+        button: 'formaction',
+        command: 'icon',
+        embed: 'src',
+        html: 'manifest',
+        input: ['src', 'formaction'],
+        source: 'src',
+        track: 'src',
+        video: ['src', 'poster']
+    };
+});

Java开发环境安装/eclipse-jee-2024-06-R-win32-x86_64/eclipse/plugins/org.eclipse.wildwebdeveloper_1.2.2.202405280856/node_modules/volar-service-html/node_modules/vscode-html-languageservice/lib/umd/languageFacts/dataProvider.js

@@ -1,3 +1,127 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:6eb61a40b3a7b4268313fa1e9d973e3799b1ddab73ed78e7b8a5dbd16765f1c1
-size 4905
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "../utils/markup"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.generateDocumentation = exports.HTMLDataProvider = void 0;
+    const markup_1 = require("../utils/markup");
+    class HTMLDataProvider {
+        isApplicable() {
+            return true;
+        }
+        /**
+         * Currently, unversioned data uses the V1 implementation
+         * In the future when the provider handles multiple versions of HTML custom data,
+         * use the latest implementation for unversioned data
+         */
+        constructor(id, customData) {
+            this.id = id;
+            this._tags = [];
+            this._tagMap = {};
+            this._valueSetMap = {};
+            this._tags = customData.tags || [];
+            this._globalAttributes = customData.globalAttributes || [];
+            this._tags.forEach(t => {
+                this._tagMap[t.name.toLowerCase()] = t;
+            });
+            if (customData.valueSets) {
+                customData.valueSets.forEach(vs => {
+                    this._valueSetMap[vs.name] = vs.values;
+                });
+            }
+        }
+        getId() {
+            return this.id;
+        }
+        provideTags() {
+            return this._tags;
+        }
+        provideAttributes(tag) {
+            const attributes = [];
+            const processAttribute = (a) => {
+                attributes.push(a);
+            };
+            const tagEntry = this._tagMap[tag.toLowerCase()];
+            if (tagEntry) {
+                tagEntry.attributes.forEach(processAttribute);
+            }
+            this._globalAttributes.forEach(processAttribute);
+            return attributes;
+        }
+        provideValues(tag, attribute) {
+            const values = [];
+            attribute = attribute.toLowerCase();
+            const processAttributes = (attributes) => {
+                attributes.forEach(a => {
+                    if (a.name.toLowerCase() === attribute) {
+                        if (a.values) {
+                            a.values.forEach(v => {
+                                values.push(v);
+                            });
+                        }
+                        if (a.valueSet) {
+                            if (this._valueSetMap[a.valueSet]) {
+                                this._valueSetMap[a.valueSet].forEach(v => {
+                                    values.push(v);
+                                });
+                            }
+                        }
+                    }
+                });
+            };
+            const tagEntry = this._tagMap[tag.toLowerCase()];
+            if (tagEntry) {
+                processAttributes(tagEntry.attributes);
+            }
+            processAttributes(this._globalAttributes);
+            return values;
+        }
+    }
+    exports.HTMLDataProvider = HTMLDataProvider;
+    /**
+     * Generate Documentation used in hover/complete
+     * From `documentation` and `references`
+     */
+    function generateDocumentation(item, settings = {}, doesSupportMarkdown) {
+        const result = {
+            kind: doesSupportMarkdown ? 'markdown' : 'plaintext',
+            value: ''
+        };
+        if (item.description && settings.documentation !== false) {
+            const normalizedDescription = (0, markup_1.normalizeMarkupContent)(item.description);
+            if (normalizedDescription) {
+                result.value += normalizedDescription.value;
+            }
+        }
+        if (item.references && item.references.length > 0 && settings.references !== false) {
+            if (result.value.length) {
+                result.value += `\n\n`;
+            }
+            if (doesSupportMarkdown) {
+                result.value += item.references.map(r => {
+                    return `[${r.name}](${r.url})`;
+                }).join(' | ');
+            }
+            else {
+                result.value += item.references.map(r => {
+                    return `${r.name}: ${r.url}`;
+                }).join('\n');
+            }
+        }
+        if (result.value === '') {
+            return undefined;
+        }
+        return result;
+    }
+    exports.generateDocumentation = generateDocumentation;
+});

Java开发环境安装/eclipse-jee-2024-06-R-win32-x86_64/eclipse/plugins/org.eclipse.wildwebdeveloper_1.2.2.202405280856/node_modules/volar-service-html/node_modules/vscode-html-languageservice/lib/umd/parser/htmlEntities.js

@@ -1,3 +1,2254 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:31922ec4c2c2e4ea94291fe57fec7c6a451f5bd724ce6d8147cf41a99257bcae
-size 68048
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.entities = void 0;
+    /**
+     * HTML 5 character entities
+     * https://www.w3.org/TR/html5/syntax.html#named-character-references
+     */
+    exports.entities = {
+        "Aacute;": "\u00C1",
+        "Aacute": "\u00C1",
+        "aacute;": "\u00E1",
+        "aacute": "\u00E1",
+        "Abreve;": "\u0102",
+        "abreve;": "\u0103",
+        "ac;": "\u223E",
+        "acd;": "\u223F",
+        "acE;": "\u223E\u0333",
+        "Acirc;": "\u00C2",
+        "Acirc": "\u00C2",
+        "acirc;": "\u00E2",
+        "acirc": "\u00E2",
+        "acute;": "\u00B4",
+        "acute": "\u00B4",
+        "Acy;": "\u0410",
+        "acy;": "\u0430",
+        "AElig;": "\u00C6",
+        "AElig": "\u00C6",
+        "aelig;": "\u00E6",
+        "aelig": "\u00E6",
+        "af;": "\u2061",
+        "Afr;": "\uD835\uDD04",
+        "afr;": "\uD835\uDD1E",
+        "Agrave;": "\u00C0",
+        "Agrave": "\u00C0",
+        "agrave;": "\u00E0",
+        "agrave": "\u00E0",
+        "alefsym;": "\u2135",
+        "aleph;": "\u2135",
+        "Alpha;": "\u0391",
+        "alpha;": "\u03B1",
+        "Amacr;": "\u0100",
+        "amacr;": "\u0101",
+        "amalg;": "\u2A3F",
+        "AMP;": "\u0026",
+        "AMP": "\u0026",
+        "amp;": "\u0026",
+        "amp": "\u0026",
+        "And;": "\u2A53",
+        "and;": "\u2227",
+        "andand;": "\u2A55",
+        "andd;": "\u2A5C",
+        "andslope;": "\u2A58",
+        "andv;": "\u2A5A",
+        "ang;": "\u2220",
+        "ange;": "\u29A4",
+        "angle;": "\u2220",
+        "angmsd;": "\u2221",
+        "angmsdaa;": "\u29A8",
+        "angmsdab;": "\u29A9",
+        "angmsdac;": "\u29AA",
+        "angmsdad;": "\u29AB",
+        "angmsdae;": "\u29AC",
+        "angmsdaf;": "\u29AD",
+        "angmsdag;": "\u29AE",
+        "angmsdah;": "\u29AF",
+        "angrt;": "\u221F",
+        "angrtvb;": "\u22BE",
+        "angrtvbd;": "\u299D",
+        "angsph;": "\u2222",
+        "angst;": "\u00C5",
+        "angzarr;": "\u237C",
+        "Aogon;": "\u0104",
+        "aogon;": "\u0105",
+        "Aopf;": "\uD835\uDD38",
+        "aopf;": "\uD835\uDD52",
+        "ap;": "\u2248",
+        "apacir;": "\u2A6F",
+        "apE;": "\u2A70",
+        "ape;": "\u224A",
+        "apid;": "\u224B",
+        "apos;": "\u0027",
+        "ApplyFunction;": "\u2061",
+        "approx;": "\u2248",
+        "approxeq;": "\u224A",
+        "Aring;": "\u00C5",
+        "Aring": "\u00C5",
+        "aring;": "\u00E5",
+        "aring": "\u00E5",
+        "Ascr;": "\uD835\uDC9C",
+        "ascr;": "\uD835\uDCB6",
+        "Assign;": "\u2254",
+        "ast;": "\u002A",
+        "asymp;": "\u2248",
+        "asympeq;": "\u224D",
+        "Atilde;": "\u00C3",
+        "Atilde": "\u00C3",
+        "atilde;": "\u00E3",
+        "atilde": "\u00E3",
+        "Auml;": "\u00C4",
+        "Auml": "\u00C4",
+        "auml;": "\u00E4",
+        "auml": "\u00E4",
+        "awconint;": "\u2233",
+        "awint;": "\u2A11",
+        "backcong;": "\u224C",
+        "backepsilon;": "\u03F6",
+        "backprime;": "\u2035",
+        "backsim;": "\u223D",
+        "backsimeq;": "\u22CD",
+        "Backslash;": "\u2216",
+        "Barv;": "\u2AE7",
+        "barvee;": "\u22BD",
+        "Barwed;": "\u2306",
+        "barwed;": "\u2305",
+        "barwedge;": "\u2305",
+        "bbrk;": "\u23B5",
+        "bbrktbrk;": "\u23B6",
+        "bcong;": "\u224C",
+        "Bcy;": "\u0411",
+        "bcy;": "\u0431",
+        "bdquo;": "\u201E",
+        "becaus;": "\u2235",
+        "Because;": "\u2235",
+        "because;": "\u2235",
+        "bemptyv;": "\u29B0",
+        "bepsi;": "\u03F6",
+        "bernou;": "\u212C",
+        "Bernoullis;": "\u212C",
+        "Beta;": "\u0392",
+        "beta;": "\u03B2",
+        "beth;": "\u2136",
+        "between;": "\u226C",
+        "Bfr;": "\uD835\uDD05",
+        "bfr;": "\uD835\uDD1F",
+        "bigcap;": "\u22C2",
+        "bigcirc;": "\u25EF",
+        "bigcup;": "\u22C3",
+        "bigodot;": "\u2A00",
+        "bigoplus;": "\u2A01",
+        "bigotimes;": "\u2A02",
+        "bigsqcup;": "\u2A06",
+        "bigstar;": "\u2605",
+        "bigtriangledown;": "\u25BD",
+        "bigtriangleup;": "\u25B3",
+        "biguplus;": "\u2A04",
+        "bigvee;": "\u22C1",
+        "bigwedge;": "\u22C0",
+        "bkarow;": "\u290D",
+        "blacklozenge;": "\u29EB",
+        "blacksquare;": "\u25AA",
+        "blacktriangle;": "\u25B4",
+        "blacktriangledown;": "\u25BE",
+        "blacktriangleleft;": "\u25C2",
+        "blacktriangleright;": "\u25B8",
+        "blank;": "\u2423",
+        "blk12;": "\u2592",
+        "blk14;": "\u2591",
+        "blk34;": "\u2593",
+        "block;": "\u2588",
+        "bne;": "\u003D\u20E5",
+        "bnequiv;": "\u2261\u20E5",
+        "bNot;": "\u2AED",
+        "bnot;": "\u2310",
+        "Bopf;": "\uD835\uDD39",
+        "bopf;": "\uD835\uDD53",
+        "bot;": "\u22A5",
+        "bottom;": "\u22A5",
+        "bowtie;": "\u22C8",
+        "boxbox;": "\u29C9",
+        "boxDL;": "\u2557",
+        "boxDl;": "\u2556",
+        "boxdL;": "\u2555",
+        "boxdl;": "\u2510",
+        "boxDR;": "\u2554",
+        "boxDr;": "\u2553",
+        "boxdR;": "\u2552",
+        "boxdr;": "\u250C",
+        "boxH;": "\u2550",
+        "boxh;": "\u2500",
+        "boxHD;": "\u2566",
+        "boxHd;": "\u2564",
+        "boxhD;": "\u2565",
+        "boxhd;": "\u252C",
+        "boxHU;": "\u2569",
+        "boxHu;": "\u2567",
+        "boxhU;": "\u2568",
+        "boxhu;": "\u2534",
+        "boxminus;": "\u229F",
+        "boxplus;": "\u229E",
+        "boxtimes;": "\u22A0",
+        "boxUL;": "\u255D",
+        "boxUl;": "\u255C",
+        "boxuL;": "\u255B",
+        "boxul;": "\u2518",
+        "boxUR;": "\u255A",
+        "boxUr;": "\u2559",
+        "boxuR;": "\u2558",
+        "boxur;": "\u2514",
+        "boxV;": "\u2551",
+        "boxv;": "\u2502",
+        "boxVH;": "\u256C",
+        "boxVh;": "\u256B",
+        "boxvH;": "\u256A",
+        "boxvh;": "\u253C",
+        "boxVL;": "\u2563",
+        "boxVl;": "\u2562",
+        "boxvL;": "\u2561",
+        "boxvl;": "\u2524",
+        "boxVR;": "\u2560",
+        "boxVr;": "\u255F",
+        "boxvR;": "\u255E",
+        "boxvr;": "\u251C",
+        "bprime;": "\u2035",
+        "Breve;": "\u02D8",
+        "breve;": "\u02D8",
+        "brvbar;": "\u00A6",
+        "brvbar": "\u00A6",
+        "Bscr;": "\u212C",
+        "bscr;": "\uD835\uDCB7",
+        "bsemi;": "\u204F",
+        "bsim;": "\u223D",
+        "bsime;": "\u22CD",
+        "bsol;": "\u005C",
+        "bsolb;": "\u29C5",
+        "bsolhsub;": "\u27C8",
+        "bull;": "\u2022",
+        "bullet;": "\u2022",
+        "bump;": "\u224E",
+        "bumpE;": "\u2AAE",
+        "bumpe;": "\u224F",
+        "Bumpeq;": "\u224E",
+        "bumpeq;": "\u224F",
+        "Cacute;": "\u0106",
+        "cacute;": "\u0107",
+        "Cap;": "\u22D2",
+        "cap;": "\u2229",
+        "capand;": "\u2A44",
+        "capbrcup;": "\u2A49",
+        "capcap;": "\u2A4B",
+        "capcup;": "\u2A47",
+        "capdot;": "\u2A40",
+        "CapitalDifferentialD;": "\u2145",
+        "caps;": "\u2229\uFE00",
+        "caret;": "\u2041",
+        "caron;": "\u02C7",
+        "Cayleys;": "\u212D",
+        "ccaps;": "\u2A4D",
+        "Ccaron;": "\u010C",
+        "ccaron;": "\u010D",
+        "Ccedil;": "\u00C7",
+        "Ccedil": "\u00C7",
+        "ccedil;": "\u00E7",
+        "ccedil": "\u00E7",
+        "Ccirc;": "\u0108",
+        "ccirc;": "\u0109",
+        "Cconint;": "\u2230",
+        "ccups;": "\u2A4C",
+        "ccupssm;": "\u2A50",
+        "Cdot;": "\u010A",
+        "cdot;": "\u010B",
+        "cedil;": "\u00B8",
+        "cedil": "\u00B8",
+        "Cedilla;": "\u00B8",
+        "cemptyv;": "\u29B2",
+        "cent;": "\u00A2",
+        "cent": "\u00A2",
+        "CenterDot;": "\u00B7",
+        "centerdot;": "\u00B7",
+        "Cfr;": "\u212D",
+        "cfr;": "\uD835\uDD20",
+        "CHcy;": "\u0427",
+        "chcy;": "\u0447",
+        "check;": "\u2713",
+        "checkmark;": "\u2713",
+        "Chi;": "\u03A7",
+        "chi;": "\u03C7",
+        "cir;": "\u25CB",
+        "circ;": "\u02C6",
+        "circeq;": "\u2257",
+        "circlearrowleft;": "\u21BA",
+        "circlearrowright;": "\u21BB",
+        "circledast;": "\u229B",
+        "circledcirc;": "\u229A",
+        "circleddash;": "\u229D",
+        "CircleDot;": "\u2299",
+        "circledR;": "\u00AE",
+        "circledS;": "\u24C8",
+        "CircleMinus;": "\u2296",
+        "CirclePlus;": "\u2295",
+        "CircleTimes;": "\u2297",
+        "cirE;": "\u29C3",
+        "cire;": "\u2257",
+        "cirfnint;": "\u2A10",
+        "cirmid;": "\u2AEF",
+        "cirscir;": "\u29C2",
+        "ClockwiseContourIntegral;": "\u2232",
+        "CloseCurlyDoubleQuote;": "\u201D",
+        "CloseCurlyQuote;": "\u2019",
+        "clubs;": "\u2663",
+        "clubsuit;": "\u2663",
+        "Colon;": "\u2237",
+        "colon;": "\u003A",
+        "Colone;": "\u2A74",
+        "colone;": "\u2254",
+        "coloneq;": "\u2254",
+        "comma;": "\u002C",
+        "commat;": "\u0040",
+        "comp;": "\u2201",
+        "compfn;": "\u2218",
+        "complement;": "\u2201",
+        "complexes;": "\u2102",
+        "cong;": "\u2245",
+        "congdot;": "\u2A6D",
+        "Congruent;": "\u2261",
+        "Conint;": "\u222F",
+        "conint;": "\u222E",
+        "ContourIntegral;": "\u222E",
+        "Copf;": "\u2102",
+        "copf;": "\uD835\uDD54",
+        "coprod;": "\u2210",
+        "Coproduct;": "\u2210",
+        "COPY;": "\u00A9",
+        "COPY": "\u00A9",
+        "copy;": "\u00A9",
+        "copy": "\u00A9",
+        "copysr;": "\u2117",
+        "CounterClockwiseContourIntegral;": "\u2233",
+        "crarr;": "\u21B5",
+        "Cross;": "\u2A2F",
+        "cross;": "\u2717",
+        "Cscr;": "\uD835\uDC9E",
+        "cscr;": "\uD835\uDCB8",
+        "csub;": "\u2ACF",
+        "csube;": "\u2AD1",
+        "csup;": "\u2AD0",
+        "csupe;": "\u2AD2",
+        "ctdot;": "\u22EF",
+        "cudarrl;": "\u2938",
+        "cudarrr;": "\u2935",
+        "cuepr;": "\u22DE",
+        "cuesc;": "\u22DF",
+        "cularr;": "\u21B6",
+        "cularrp;": "\u293D",
+        "Cup;": "\u22D3",
+        "cup;": "\u222A",
+        "cupbrcap;": "\u2A48",
+        "CupCap;": "\u224D",
+        "cupcap;": "\u2A46",
+        "cupcup;": "\u2A4A",
+        "cupdot;": "\u228D",
+        "cupor;": "\u2A45",
+        "cups;": "\u222A\uFE00",
+        "curarr;": "\u21B7",
+        "curarrm;": "\u293C",
+        "curlyeqprec;": "\u22DE",
+        "curlyeqsucc;": "\u22DF",
+        "curlyvee;": "\u22CE",
+        "curlywedge;": "\u22CF",
+        "curren;": "\u00A4",
+        "curren": "\u00A4",
+        "curvearrowleft;": "\u21B6",
+        "curvearrowright;": "\u21B7",
+        "cuvee;": "\u22CE",
+        "cuwed;": "\u22CF",
+        "cwconint;": "\u2232",
+        "cwint;": "\u2231",
+        "cylcty;": "\u232D",
+        "Dagger;": "\u2021",
+        "dagger;": "\u2020",
+        "daleth;": "\u2138",
+        "Darr;": "\u21A1",
+        "dArr;": "\u21D3",
+        "darr;": "\u2193",
+        "dash;": "\u2010",
+        "Dashv;": "\u2AE4",
+        "dashv;": "\u22A3",
+        "dbkarow;": "\u290F",
+        "dblac;": "\u02DD",
+        "Dcaron;": "\u010E",
+        "dcaron;": "\u010F",
+        "Dcy;": "\u0414",
+        "dcy;": "\u0434",
+        "DD;": "\u2145",
+        "dd;": "\u2146",
+        "ddagger;": "\u2021",
+        "ddarr;": "\u21CA",
+        "DDotrahd;": "\u2911",
+        "ddotseq;": "\u2A77",
+        "deg;": "\u00B0",
+        "deg": "\u00B0",
+        "Del;": "\u2207",
+        "Delta;": "\u0394",
+        "delta;": "\u03B4",
+        "demptyv;": "\u29B1",
+        "dfisht;": "\u297F",
+        "Dfr;": "\uD835\uDD07",
+        "dfr;": "\uD835\uDD21",
+        "dHar;": "\u2965",
+        "dharl;": "\u21C3",
+        "dharr;": "\u21C2",
+        "DiacriticalAcute;": "\u00B4",
+        "DiacriticalDot;": "\u02D9",
+        "DiacriticalDoubleAcute;": "\u02DD",
+        "DiacriticalGrave;": "\u0060",
+        "DiacriticalTilde;": "\u02DC",
+        "diam;": "\u22C4",
+        "Diamond;": "\u22C4",
+        "diamond;": "\u22C4",
+        "diamondsuit;": "\u2666",
+        "diams;": "\u2666",
+        "die;": "\u00A8",
+        "DifferentialD;": "\u2146",
+        "digamma;": "\u03DD",
+        "disin;": "\u22F2",
+        "div;": "\u00F7",
+        "divide;": "\u00F7",
+        "divide": "\u00F7",
+        "divideontimes;": "\u22C7",
+        "divonx;": "\u22C7",
+        "DJcy;": "\u0402",
+        "djcy;": "\u0452",
+        "dlcorn;": "\u231E",
+        "dlcrop;": "\u230D",
+        "dollar;": "\u0024",
+        "Dopf;": "\uD835\uDD3B",
+        "dopf;": "\uD835\uDD55",
+        "Dot;": "\u00A8",
+        "dot;": "\u02D9",
+        "DotDot;": "\u20DC",
+        "doteq;": "\u2250",
+        "doteqdot;": "\u2251",
+        "DotEqual;": "\u2250",
+        "dotminus;": "\u2238",
+        "dotplus;": "\u2214",
+        "dotsquare;": "\u22A1",
+        "doublebarwedge;": "\u2306",
+        "DoubleContourIntegral;": "\u222F",
+        "DoubleDot;": "\u00A8",
+        "DoubleDownArrow;": "\u21D3",
+        "DoubleLeftArrow;": "\u21D0",
+        "DoubleLeftRightArrow;": "\u21D4",
+        "DoubleLeftTee;": "\u2AE4",
+        "DoubleLongLeftArrow;": "\u27F8",
+        "DoubleLongLeftRightArrow;": "\u27FA",
+        "DoubleLongRightArrow;": "\u27F9",
+        "DoubleRightArrow;": "\u21D2",
+        "DoubleRightTee;": "\u22A8",
+        "DoubleUpArrow;": "\u21D1",
+        "DoubleUpDownArrow;": "\u21D5",
+        "DoubleVerticalBar;": "\u2225",
+        "DownArrow;": "\u2193",
+        "Downarrow;": "\u21D3",
+        "downarrow;": "\u2193",
+        "DownArrowBar;": "\u2913",
+        "DownArrowUpArrow;": "\u21F5",
+        "DownBreve;": "\u0311",
+        "downdownarrows;": "\u21CA",
+        "downharpoonleft;": "\u21C3",
+        "downharpoonright;": "\u21C2",
+        "DownLeftRightVector;": "\u2950",
+        "DownLeftTeeVector;": "\u295E",
+        "DownLeftVector;": "\u21BD",
+        "DownLeftVectorBar;": "\u2956",
+        "DownRightTeeVector;": "\u295F",
+        "DownRightVector;": "\u21C1",
+        "DownRightVectorBar;": "\u2957",
+        "DownTee;": "\u22A4",
+        "DownTeeArrow;": "\u21A7",
+        "drbkarow;": "\u2910",
+        "drcorn;": "\u231F",
+        "drcrop;": "\u230C",
+        "Dscr;": "\uD835\uDC9F",
+        "dscr;": "\uD835\uDCB9",
+        "DScy;": "\u0405",
+        "dscy;": "\u0455",
+        "dsol;": "\u29F6",
+        "Dstrok;": "\u0110",
+        "dstrok;": "\u0111",
+        "dtdot;": "\u22F1",
+        "dtri;": "\u25BF",
+        "dtrif;": "\u25BE",
+        "duarr;": "\u21F5",
+        "duhar;": "\u296F",
+        "dwangle;": "\u29A6",
+        "DZcy;": "\u040F",
+        "dzcy;": "\u045F",
+        "dzigrarr;": "\u27FF",
+        "Eacute;": "\u00C9",
+        "Eacute": "\u00C9",
+        "eacute;": "\u00E9",
+        "eacute": "\u00E9",
+        "easter;": "\u2A6E",
+        "Ecaron;": "\u011A",
+        "ecaron;": "\u011B",
+        "ecir;": "\u2256",
+        "Ecirc;": "\u00CA",
+        "Ecirc": "\u00CA",
+        "ecirc;": "\u00EA",
+        "ecirc": "\u00EA",
+        "ecolon;": "\u2255",
+        "Ecy;": "\u042D",
+        "ecy;": "\u044D",
+        "eDDot;": "\u2A77",
+        "Edot;": "\u0116",
+        "eDot;": "\u2251",
+        "edot;": "\u0117",
+        "ee;": "\u2147",
+        "efDot;": "\u2252",
+        "Efr;": "\uD835\uDD08",
+        "efr;": "\uD835\uDD22",
+        "eg;": "\u2A9A",
+        "Egrave;": "\u00C8",
+        "Egrave": "\u00C8",
+        "egrave;": "\u00E8",
+        "egrave": "\u00E8",
+        "egs;": "\u2A96",
+        "egsdot;": "\u2A98",
+        "el;": "\u2A99",
+        "Element;": "\u2208",
+        "elinters;": "\u23E7",
+        "ell;": "\u2113",
+        "els;": "\u2A95",
+        "elsdot;": "\u2A97",
+        "Emacr;": "\u0112",
+        "emacr;": "\u0113",
+        "empty;": "\u2205",
+        "emptyset;": "\u2205",
+        "EmptySmallSquare;": "\u25FB",
+        "emptyv;": "\u2205",
+        "EmptyVerySmallSquare;": "\u25AB",
+        "emsp;": "\u2003",
+        "emsp13;": "\u2004",
+        "emsp14;": "\u2005",
+        "ENG;": "\u014A",
+        "eng;": "\u014B",
+        "ensp;": "\u2002",
+        "Eogon;": "\u0118",
+        "eogon;": "\u0119",
+        "Eopf;": "\uD835\uDD3C",
+        "eopf;": "\uD835\uDD56",
+        "epar;": "\u22D5",
+        "eparsl;": "\u29E3",
+        "eplus;": "\u2A71",
+        "epsi;": "\u03B5",
+        "Epsilon;": "\u0395",
+        "epsilon;": "\u03B5",
+        "epsiv;": "\u03F5",
+        "eqcirc;": "\u2256",
+        "eqcolon;": "\u2255",
+        "eqsim;": "\u2242",
+        "eqslantgtr;": "\u2A96",
+        "eqslantless;": "\u2A95",
+        "Equal;": "\u2A75",
+        "equals;": "\u003D",
+        "EqualTilde;": "\u2242",
+        "equest;": "\u225F",
+        "Equilibrium;": "\u21CC",
+        "equiv;": "\u2261",
+        "equivDD;": "\u2A78",
+        "eqvparsl;": "\u29E5",
+        "erarr;": "\u2971",
+        "erDot;": "\u2253",
+        "Escr;": "\u2130",
+        "escr;": "\u212F",
+        "esdot;": "\u2250",
+        "Esim;": "\u2A73",
+        "esim;": "\u2242",
+        "Eta;": "\u0397",
+        "eta;": "\u03B7",
+        "ETH;": "\u00D0",
+        "ETH": "\u00D0",
+        "eth;": "\u00F0",
+        "eth": "\u00F0",
+        "Euml;": "\u00CB",
+        "Euml": "\u00CB",
+        "euml;": "\u00EB",
+        "euml": "\u00EB",
+        "euro;": "\u20AC",
+        "excl;": "\u0021",
+        "exist;": "\u2203",
+        "Exists;": "\u2203",
+        "expectation;": "\u2130",
+        "ExponentialE;": "\u2147",
+        "exponentiale;": "\u2147",
+        "fallingdotseq;": "\u2252",
+        "Fcy;": "\u0424",
+        "fcy;": "\u0444",
+        "female;": "\u2640",
+        "ffilig;": "\uFB03",
+        "fflig;": "\uFB00",
+        "ffllig;": "\uFB04",
+        "Ffr;": "\uD835\uDD09",
+        "ffr;": "\uD835\uDD23",
+        "filig;": "\uFB01",
+        "FilledSmallSquare;": "\u25FC",
+        "FilledVerySmallSquare;": "\u25AA",
+        "fjlig;": "\u0066\u006A",
+        "flat;": "\u266D",
+        "fllig;": "\uFB02",
+        "fltns;": "\u25B1",
+        "fnof;": "\u0192",
+        "Fopf;": "\uD835\uDD3D",
+        "fopf;": "\uD835\uDD57",
+        "ForAll;": "\u2200",
+        "forall;": "\u2200",
+        "fork;": "\u22D4",
+        "forkv;": "\u2AD9",
+        "Fouriertrf;": "\u2131",
+        "fpartint;": "\u2A0D",
+        "frac12;": "\u00BD",
+        "frac12": "\u00BD",
+        "frac13;": "\u2153",
+        "frac14;": "\u00BC",
+        "frac14": "\u00BC",
+        "frac15;": "\u2155",
+        "frac16;": "\u2159",
+        "frac18;": "\u215B",
+        "frac23;": "\u2154",
+        "frac25;": "\u2156",
+        "frac34;": "\u00BE",
+        "frac34": "\u00BE",
+        "frac35;": "\u2157",
+        "frac38;": "\u215C",
+        "frac45;": "\u2158",
+        "frac56;": "\u215A",
+        "frac58;": "\u215D",
+        "frac78;": "\u215E",
+        "frasl;": "\u2044",
+        "frown;": "\u2322",
+        "Fscr;": "\u2131",
+        "fscr;": "\uD835\uDCBB",
+        "gacute;": "\u01F5",
+        "Gamma;": "\u0393",
+        "gamma;": "\u03B3",
+        "Gammad;": "\u03DC",
+        "gammad;": "\u03DD",
+        "gap;": "\u2A86",
+        "Gbreve;": "\u011E",
+        "gbreve;": "\u011F",
+        "Gcedil;": "\u0122",
+        "Gcirc;": "\u011C",
+        "gcirc;": "\u011D",
+        "Gcy;": "\u0413",
+        "gcy;": "\u0433",
+        "Gdot;": "\u0120",
+        "gdot;": "\u0121",
+        "gE;": "\u2267",
+        "ge;": "\u2265",
+        "gEl;": "\u2A8C",
+        "gel;": "\u22DB",
+        "geq;": "\u2265",
+        "geqq;": "\u2267",
+        "geqslant;": "\u2A7E",
+        "ges;": "\u2A7E",
+        "gescc;": "\u2AA9",
+        "gesdot;": "\u2A80",
+        "gesdoto;": "\u2A82",
+        "gesdotol;": "\u2A84",
+        "gesl;": "\u22DB\uFE00",
+        "gesles;": "\u2A94",
+        "Gfr;": "\uD835\uDD0A",
+        "gfr;": "\uD835\uDD24",
+        "Gg;": "\u22D9",
+        "gg;": "\u226B",
+        "ggg;": "\u22D9",
+        "gimel;": "\u2137",
+        "GJcy;": "\u0403",
+        "gjcy;": "\u0453",
+        "gl;": "\u2277",
+        "gla;": "\u2AA5",
+        "glE;": "\u2A92",
+        "glj;": "\u2AA4",
+        "gnap;": "\u2A8A",
+        "gnapprox;": "\u2A8A",
+        "gnE;": "\u2269",
+        "gne;": "\u2A88",
+        "gneq;": "\u2A88",
+        "gneqq;": "\u2269",
+        "gnsim;": "\u22E7",
+        "Gopf;": "\uD835\uDD3E",
+        "gopf;": "\uD835\uDD58",
+        "grave;": "\u0060",
+        "GreaterEqual;": "\u2265",
+        "GreaterEqualLess;": "\u22DB",
+        "GreaterFullEqual;": "\u2267",
+        "GreaterGreater;": "\u2AA2",
+        "GreaterLess;": "\u2277",
+        "GreaterSlantEqual;": "\u2A7E",
+        "GreaterTilde;": "\u2273",
+        "Gscr;": "\uD835\uDCA2",
+        "gscr;": "\u210A",
+        "gsim;": "\u2273",
+        "gsime;": "\u2A8E",
+        "gsiml;": "\u2A90",
+        "GT;": "\u003E",
+        "GT": "\u003E",
+        "Gt;": "\u226B",
+        "gt;": "\u003E",
+        "gt": "\u003E",
+        "gtcc;": "\u2AA7",
+        "gtcir;": "\u2A7A",
+        "gtdot;": "\u22D7",
+        "gtlPar;": "\u2995",
+        "gtquest;": "\u2A7C",
+        "gtrapprox;": "\u2A86",
+        "gtrarr;": "\u2978",
+        "gtrdot;": "\u22D7",
+        "gtreqless;": "\u22DB",
+        "gtreqqless;": "\u2A8C",
+        "gtrless;": "\u2277",
+        "gtrsim;": "\u2273",
+        "gvertneqq;": "\u2269\uFE00",
+        "gvnE;": "\u2269\uFE00",
+        "Hacek;": "\u02C7",
+        "hairsp;": "\u200A",
+        "half;": "\u00BD",
+        "hamilt;": "\u210B",
+        "HARDcy;": "\u042A",
+        "hardcy;": "\u044A",
+        "hArr;": "\u21D4",
+        "harr;": "\u2194",
+        "harrcir;": "\u2948",
+        "harrw;": "\u21AD",
+        "Hat;": "\u005E",
+        "hbar;": "\u210F",
+        "Hcirc;": "\u0124",
+        "hcirc;": "\u0125",
+        "hearts;": "\u2665",
+        "heartsuit;": "\u2665",
+        "hellip;": "\u2026",
+        "hercon;": "\u22B9",
+        "Hfr;": "\u210C",
+        "hfr;": "\uD835\uDD25",
+        "HilbertSpace;": "\u210B",
+        "hksearow;": "\u2925",
+        "hkswarow;": "\u2926",
+        "hoarr;": "\u21FF",
+        "homtht;": "\u223B",
+        "hookleftarrow;": "\u21A9",
+        "hookrightarrow;": "\u21AA",
+        "Hopf;": "\u210D",
+        "hopf;": "\uD835\uDD59",
+        "horbar;": "\u2015",
+        "HorizontalLine;": "\u2500",
+        "Hscr;": "\u210B",
+        "hscr;": "\uD835\uDCBD",
+        "hslash;": "\u210F",
+        "Hstrok;": "\u0126",
+        "hstrok;": "\u0127",
+        "HumpDownHump;": "\u224E",
+        "HumpEqual;": "\u224F",
+        "hybull;": "\u2043",
+        "hyphen;": "\u2010",
+        "Iacute;": "\u00CD",
+        "Iacute": "\u00CD",
+        "iacute;": "\u00ED",
+        "iacute": "\u00ED",
+        "ic;": "\u2063",
+        "Icirc;": "\u00CE",
+        "Icirc": "\u00CE",
+        "icirc;": "\u00EE",
+        "icirc": "\u00EE",
+        "Icy;": "\u0418",
+        "icy;": "\u0438",
+        "Idot;": "\u0130",
+        "IEcy;": "\u0415",
+        "iecy;": "\u0435",
+        "iexcl;": "\u00A1",
+        "iexcl": "\u00A1",
+        "iff;": "\u21D4",
+        "Ifr;": "\u2111",
+        "ifr;": "\uD835\uDD26",
+        "Igrave;": "\u00CC",
+        "Igrave": "\u00CC",
+        "igrave;": "\u00EC",
+        "igrave": "\u00EC",
+        "ii;": "\u2148",
+        "iiiint;": "\u2A0C",
+        "iiint;": "\u222D",
+        "iinfin;": "\u29DC",
+        "iiota;": "\u2129",
+        "IJlig;": "\u0132",
+        "ijlig;": "\u0133",
+        "Im;": "\u2111",
+        "Imacr;": "\u012A",
+        "imacr;": "\u012B",
+        "image;": "\u2111",
+        "ImaginaryI;": "\u2148",
+        "imagline;": "\u2110",
+        "imagpart;": "\u2111",
+        "imath;": "\u0131",
+        "imof;": "\u22B7",
+        "imped;": "\u01B5",
+        "Implies;": "\u21D2",
+        "in;": "\u2208",
+        "incare;": "\u2105",
+        "infin;": "\u221E",
+        "infintie;": "\u29DD",
+        "inodot;": "\u0131",
+        "Int;": "\u222C",
+        "int;": "\u222B",
+        "intcal;": "\u22BA",
+        "integers;": "\u2124",
+        "Integral;": "\u222B",
+        "intercal;": "\u22BA",
+        "Intersection;": "\u22C2",
+        "intlarhk;": "\u2A17",
+        "intprod;": "\u2A3C",
+        "InvisibleComma;": "\u2063",
+        "InvisibleTimes;": "\u2062",
+        "IOcy;": "\u0401",
+        "iocy;": "\u0451",
+        "Iogon;": "\u012E",
+        "iogon;": "\u012F",
+        "Iopf;": "\uD835\uDD40",
+        "iopf;": "\uD835\uDD5A",
+        "Iota;": "\u0399",
+        "iota;": "\u03B9",
+        "iprod;": "\u2A3C",
+        "iquest;": "\u00BF",
+        "iquest": "\u00BF",
+        "Iscr;": "\u2110",
+        "iscr;": "\uD835\uDCBE",
+        "isin;": "\u2208",
+        "isindot;": "\u22F5",
+        "isinE;": "\u22F9",
+        "isins;": "\u22F4",
+        "isinsv;": "\u22F3",
+        "isinv;": "\u2208",
+        "it;": "\u2062",
+        "Itilde;": "\u0128",
+        "itilde;": "\u0129",
+        "Iukcy;": "\u0406",
+        "iukcy;": "\u0456",
+        "Iuml;": "\u00CF",
+        "Iuml": "\u00CF",
+        "iuml;": "\u00EF",
+        "iuml": "\u00EF",
+        "Jcirc;": "\u0134",
+        "jcirc;": "\u0135",
+        "Jcy;": "\u0419",
+        "jcy;": "\u0439",
+        "Jfr;": "\uD835\uDD0D",
+        "jfr;": "\uD835\uDD27",
+        "jmath;": "\u0237",
+        "Jopf;": "\uD835\uDD41",
+        "jopf;": "\uD835\uDD5B",
+        "Jscr;": "\uD835\uDCA5",
+        "jscr;": "\uD835\uDCBF",
+        "Jsercy;": "\u0408",
+        "jsercy;": "\u0458",
+        "Jukcy;": "\u0404",
+        "jukcy;": "\u0454",
+        "Kappa;": "\u039A",
+        "kappa;": "\u03BA",
+        "kappav;": "\u03F0",
+        "Kcedil;": "\u0136",
+        "kcedil;": "\u0137",
+        "Kcy;": "\u041A",
+        "kcy;": "\u043A",
+        "Kfr;": "\uD835\uDD0E",
+        "kfr;": "\uD835\uDD28",
+        "kgreen;": "\u0138",
+        "KHcy;": "\u0425",
+        "khcy;": "\u0445",
+        "KJcy;": "\u040C",
+        "kjcy;": "\u045C",
+        "Kopf;": "\uD835\uDD42",
+        "kopf;": "\uD835\uDD5C",
+        "Kscr;": "\uD835\uDCA6",
+        "kscr;": "\uD835\uDCC0",
+        "lAarr;": "\u21DA",
+        "Lacute;": "\u0139",
+        "lacute;": "\u013A",
+        "laemptyv;": "\u29B4",
+        "lagran;": "\u2112",
+        "Lambda;": "\u039B",
+        "lambda;": "\u03BB",
+        "Lang;": "\u27EA",
+        "lang;": "\u27E8",
+        "langd;": "\u2991",
+        "langle;": "\u27E8",
+        "lap;": "\u2A85",
+        "Laplacetrf;": "\u2112",
+        "laquo;": "\u00AB",
+        "laquo": "\u00AB",
+        "Larr;": "\u219E",
+        "lArr;": "\u21D0",
+        "larr;": "\u2190",
+        "larrb;": "\u21E4",
+        "larrbfs;": "\u291F",
+        "larrfs;": "\u291D",
+        "larrhk;": "\u21A9",
+        "larrlp;": "\u21AB",
+        "larrpl;": "\u2939",
+        "larrsim;": "\u2973",
+        "larrtl;": "\u21A2",
+        "lat;": "\u2AAB",
+        "lAtail;": "\u291B",
+        "latail;": "\u2919",
+        "late;": "\u2AAD",
+        "lates;": "\u2AAD\uFE00",
+        "lBarr;": "\u290E",
+        "lbarr;": "\u290C",
+        "lbbrk;": "\u2772",
+        "lbrace;": "\u007B",
+        "lbrack;": "\u005B",
+        "lbrke;": "\u298B",
+        "lbrksld;": "\u298F",
+        "lbrkslu;": "\u298D",
+        "Lcaron;": "\u013D",
+        "lcaron;": "\u013E",
+        "Lcedil;": "\u013B",
+        "lcedil;": "\u013C",
+        "lceil;": "\u2308",
+        "lcub;": "\u007B",
+        "Lcy;": "\u041B",
+        "lcy;": "\u043B",
+        "ldca;": "\u2936",
+        "ldquo;": "\u201C",
+        "ldquor;": "\u201E",
+        "ldrdhar;": "\u2967",
+        "ldrushar;": "\u294B",
+        "ldsh;": "\u21B2",
+        "lE;": "\u2266",
+        "le;": "\u2264",
+        "LeftAngleBracket;": "\u27E8",
+        "LeftArrow;": "\u2190",
+        "Leftarrow;": "\u21D0",
+        "leftarrow;": "\u2190",
+        "LeftArrowBar;": "\u21E4",
+        "LeftArrowRightArrow;": "\u21C6",
+        "leftarrowtail;": "\u21A2",
+        "LeftCeiling;": "\u2308",
+        "LeftDoubleBracket;": "\u27E6",
+        "LeftDownTeeVector;": "\u2961",
+        "LeftDownVector;": "\u21C3",
+        "LeftDownVectorBar;": "\u2959",
+        "LeftFloor;": "\u230A",
+        "leftharpoondown;": "\u21BD",
+        "leftharpoonup;": "\u21BC",
+        "leftleftarrows;": "\u21C7",
+        "LeftRightArrow;": "\u2194",
+        "Leftrightarrow;": "\u21D4",
+        "leftrightarrow;": "\u2194",
+        "leftrightarrows;": "\u21C6",
+        "leftrightharpoons;": "\u21CB",
+        "leftrightsquigarrow;": "\u21AD",
+        "LeftRightVector;": "\u294E",
+        "LeftTee;": "\u22A3",
+        "LeftTeeArrow;": "\u21A4",
+        "LeftTeeVector;": "\u295A",
+        "leftthreetimes;": "\u22CB",
+        "LeftTriangle;": "\u22B2",
+        "LeftTriangleBar;": "\u29CF",
+        "LeftTriangleEqual;": "\u22B4",
+        "LeftUpDownVector;": "\u2951",
+        "LeftUpTeeVector;": "\u2960",
+        "LeftUpVector;": "\u21BF",
+        "LeftUpVectorBar;": "\u2958",
+        "LeftVector;": "\u21BC",
+        "LeftVectorBar;": "\u2952",
+        "lEg;": "\u2A8B",
+        "leg;": "\u22DA",
+        "leq;": "\u2264",
+        "leqq;": "\u2266",
+        "leqslant;": "\u2A7D",
+        "les;": "\u2A7D",
+        "lescc;": "\u2AA8",
+        "lesdot;": "\u2A7F",
+        "lesdoto;": "\u2A81",
+        "lesdotor;": "\u2A83",
+        "lesg;": "\u22DA\uFE00",
+        "lesges;": "\u2A93",
+        "lessapprox;": "\u2A85",
+        "lessdot;": "\u22D6",
+        "lesseqgtr;": "\u22DA",
+        "lesseqqgtr;": "\u2A8B",
+        "LessEqualGreater;": "\u22DA",
+        "LessFullEqual;": "\u2266",
+        "LessGreater;": "\u2276",
+        "lessgtr;": "\u2276",
+        "LessLess;": "\u2AA1",
+        "lesssim;": "\u2272",
+        "LessSlantEqual;": "\u2A7D",
+        "LessTilde;": "\u2272",
+        "lfisht;": "\u297C",
+        "lfloor;": "\u230A",
+        "Lfr;": "\uD835\uDD0F",
+        "lfr;": "\uD835\uDD29",
+        "lg;": "\u2276",
+        "lgE;": "\u2A91",
+        "lHar;": "\u2962",
+        "lhard;": "\u21BD",
+        "lharu;": "\u21BC",
+        "lharul;": "\u296A",
+        "lhblk;": "\u2584",
+        "LJcy;": "\u0409",
+        "ljcy;": "\u0459",
+        "Ll;": "\u22D8",
+        "ll;": "\u226A",
+        "llarr;": "\u21C7",
+        "llcorner;": "\u231E",
+        "Lleftarrow;": "\u21DA",
+        "llhard;": "\u296B",
+        "lltri;": "\u25FA",
+        "Lmidot;": "\u013F",
+        "lmidot;": "\u0140",
+        "lmoust;": "\u23B0",
+        "lmoustache;": "\u23B0",
+        "lnap;": "\u2A89",
+        "lnapprox;": "\u2A89",
+        "lnE;": "\u2268",
+        "lne;": "\u2A87",
+        "lneq;": "\u2A87",
+        "lneqq;": "\u2268",
+        "lnsim;": "\u22E6",
+        "loang;": "\u27EC",
+        "loarr;": "\u21FD",
+        "lobrk;": "\u27E6",
+        "LongLeftArrow;": "\u27F5",
+        "Longleftarrow;": "\u27F8",
+        "longleftarrow;": "\u27F5",
+        "LongLeftRightArrow;": "\u27F7",
+        "Longleftrightarrow;": "\u27FA",
+        "longleftrightarrow;": "\u27F7",
+        "longmapsto;": "\u27FC",
+        "LongRightArrow;": "\u27F6",
+        "Longrightarrow;": "\u27F9",
+        "longrightarrow;": "\u27F6",
+        "looparrowleft;": "\u21AB",
+        "looparrowright;": "\u21AC",
+        "lopar;": "\u2985",
+        "Lopf;": "\uD835\uDD43",
+        "lopf;": "\uD835\uDD5D",
+        "loplus;": "\u2A2D",
+        "lotimes;": "\u2A34",
+        "lowast;": "\u2217",
+        "lowbar;": "\u005F",
+        "LowerLeftArrow;": "\u2199",
+        "LowerRightArrow;": "\u2198",
+        "loz;": "\u25CA",
+        "lozenge;": "\u25CA",
+        "lozf;": "\u29EB",
+        "lpar;": "\u0028",
+        "lparlt;": "\u2993",
+        "lrarr;": "\u21C6",
+        "lrcorner;": "\u231F",
+        "lrhar;": "\u21CB",
+        "lrhard;": "\u296D",
+        "lrm;": "\u200E",
+        "lrtri;": "\u22BF",
+        "lsaquo;": "\u2039",
+        "Lscr;": "\u2112",
+        "lscr;": "\uD835\uDCC1",
+        "Lsh;": "\u21B0",
+        "lsh;": "\u21B0",
+        "lsim;": "\u2272",
+        "lsime;": "\u2A8D",
+        "lsimg;": "\u2A8F",
+        "lsqb;": "\u005B",
+        "lsquo;": "\u2018",
+        "lsquor;": "\u201A",
+        "Lstrok;": "\u0141",
+        "lstrok;": "\u0142",
+        "LT;": "\u003C",
+        "LT": "\u003C",
+        "Lt;": "\u226A",
+        "lt;": "\u003C",
+        "lt": "\u003C",
+        "ltcc;": "\u2AA6",
+        "ltcir;": "\u2A79",
+        "ltdot;": "\u22D6",
+        "lthree;": "\u22CB",
+        "ltimes;": "\u22C9",
+        "ltlarr;": "\u2976",
+        "ltquest;": "\u2A7B",
+        "ltri;": "\u25C3",
+        "ltrie;": "\u22B4",
+        "ltrif;": "\u25C2",
+        "ltrPar;": "\u2996",
+        "lurdshar;": "\u294A",
+        "luruhar;": "\u2966",
+        "lvertneqq;": "\u2268\uFE00",
+        "lvnE;": "\u2268\uFE00",
+        "macr;": "\u00AF",
+        "macr": "\u00AF",
+        "male;": "\u2642",
+        "malt;": "\u2720",
+        "maltese;": "\u2720",
+        "Map;": "\u2905",
+        "map;": "\u21A6",
+        "mapsto;": "\u21A6",
+        "mapstodown;": "\u21A7",
+        "mapstoleft;": "\u21A4",
+        "mapstoup;": "\u21A5",
+        "marker;": "\u25AE",
+        "mcomma;": "\u2A29",
+        "Mcy;": "\u041C",
+        "mcy;": "\u043C",
+        "mdash;": "\u2014",
+        "mDDot;": "\u223A",
+        "measuredangle;": "\u2221",
+        "MediumSpace;": "\u205F",
+        "Mellintrf;": "\u2133",
+        "Mfr;": "\uD835\uDD10",
+        "mfr;": "\uD835\uDD2A",
+        "mho;": "\u2127",
+        "micro;": "\u00B5",
+        "micro": "\u00B5",
+        "mid;": "\u2223",
+        "midast;": "\u002A",
+        "midcir;": "\u2AF0",
+        "middot;": "\u00B7",
+        "middot": "\u00B7",
+        "minus;": "\u2212",
+        "minusb;": "\u229F",
+        "minusd;": "\u2238",
+        "minusdu;": "\u2A2A",
+        "MinusPlus;": "\u2213",
+        "mlcp;": "\u2ADB",
+        "mldr;": "\u2026",
+        "mnplus;": "\u2213",
+        "models;": "\u22A7",
+        "Mopf;": "\uD835\uDD44",
+        "mopf;": "\uD835\uDD5E",
+        "mp;": "\u2213",
+        "Mscr;": "\u2133",
+        "mscr;": "\uD835\uDCC2",
+        "mstpos;": "\u223E",
+        "Mu;": "\u039C",
+        "mu;": "\u03BC",
+        "multimap;": "\u22B8",
+        "mumap;": "\u22B8",
+        "nabla;": "\u2207",
+        "Nacute;": "\u0143",
+        "nacute;": "\u0144",
+        "nang;": "\u2220\u20D2",
+        "nap;": "\u2249",
+        "napE;": "\u2A70\u0338",
+        "napid;": "\u224B\u0338",
+        "napos;": "\u0149",
+        "napprox;": "\u2249",
+        "natur;": "\u266E",
+        "natural;": "\u266E",
+        "naturals;": "\u2115",
+        "nbsp;": "\u00A0",
+        "nbsp": "\u00A0",
+        "nbump;": "\u224E\u0338",
+        "nbumpe;": "\u224F\u0338",
+        "ncap;": "\u2A43",
+        "Ncaron;": "\u0147",
+        "ncaron;": "\u0148",
+        "Ncedil;": "\u0145",
+        "ncedil;": "\u0146",
+        "ncong;": "\u2247",
+        "ncongdot;": "\u2A6D\u0338",
+        "ncup;": "\u2A42",
+        "Ncy;": "\u041D",
+        "ncy;": "\u043D",
+        "ndash;": "\u2013",
+        "ne;": "\u2260",
+        "nearhk;": "\u2924",
+        "neArr;": "\u21D7",
+        "nearr;": "\u2197",
+        "nearrow;": "\u2197",
+        "nedot;": "\u2250\u0338",
+        "NegativeMediumSpace;": "\u200B",
+        "NegativeThickSpace;": "\u200B",
+        "NegativeThinSpace;": "\u200B",
+        "NegativeVeryThinSpace;": "\u200B",
+        "nequiv;": "\u2262",
+        "nesear;": "\u2928",
+        "nesim;": "\u2242\u0338",
+        "NestedGreaterGreater;": "\u226B",
+        "NestedLessLess;": "\u226A",
+        "NewLine;": "\u000A",
+        "nexist;": "\u2204",
+        "nexists;": "\u2204",
+        "Nfr;": "\uD835\uDD11",
+        "nfr;": "\uD835\uDD2B",
+        "ngE;": "\u2267\u0338",
+        "nge;": "\u2271",
+        "ngeq;": "\u2271",
+        "ngeqq;": "\u2267\u0338",
+        "ngeqslant;": "\u2A7E\u0338",
+        "nges;": "\u2A7E\u0338",
+        "nGg;": "\u22D9\u0338",
+        "ngsim;": "\u2275",
+        "nGt;": "\u226B\u20D2",
+        "ngt;": "\u226F",
+        "ngtr;": "\u226F",
+        "nGtv;": "\u226B\u0338",
+        "nhArr;": "\u21CE",
+        "nharr;": "\u21AE",
+        "nhpar;": "\u2AF2",
+        "ni;": "\u220B",
+        "nis;": "\u22FC",
+        "nisd;": "\u22FA",
+        "niv;": "\u220B",
+        "NJcy;": "\u040A",
+        "njcy;": "\u045A",
+        "nlArr;": "\u21CD",
+        "nlarr;": "\u219A",
+        "nldr;": "\u2025",
+        "nlE;": "\u2266\u0338",
+        "nle;": "\u2270",
+        "nLeftarrow;": "\u21CD",
+        "nleftarrow;": "\u219A",
+        "nLeftrightarrow;": "\u21CE",
+        "nleftrightarrow;": "\u21AE",
+        "nleq;": "\u2270",
+        "nleqq;": "\u2266\u0338",
+        "nleqslant;": "\u2A7D\u0338",
+        "nles;": "\u2A7D\u0338",
+        "nless;": "\u226E",
+        "nLl;": "\u22D8\u0338",
+        "nlsim;": "\u2274",
+        "nLt;": "\u226A\u20D2",
+        "nlt;": "\u226E",
+        "nltri;": "\u22EA",
+        "nltrie;": "\u22EC",
+        "nLtv;": "\u226A\u0338",
+        "nmid;": "\u2224",
+        "NoBreak;": "\u2060",
+        "NonBreakingSpace;": "\u00A0",
+        "Nopf;": "\u2115",
+        "nopf;": "\uD835\uDD5F",
+        "Not;": "\u2AEC",
+        "not;": "\u00AC",
+        "not": "\u00AC",
+        "NotCongruent;": "\u2262",
+        "NotCupCap;": "\u226D",
+        "NotDoubleVerticalBar;": "\u2226",
+        "NotElement;": "\u2209",
+        "NotEqual;": "\u2260",
+        "NotEqualTilde;": "\u2242\u0338",
+        "NotExists;": "\u2204",
+        "NotGreater;": "\u226F",
+        "NotGreaterEqual;": "\u2271",
+        "NotGreaterFullEqual;": "\u2267\u0338",
+        "NotGreaterGreater;": "\u226B\u0338",
+        "NotGreaterLess;": "\u2279",
+        "NotGreaterSlantEqual;": "\u2A7E\u0338",
+        "NotGreaterTilde;": "\u2275",
+        "NotHumpDownHump;": "\u224E\u0338",
+        "NotHumpEqual;": "\u224F\u0338",
+        "notin;": "\u2209",
+        "notindot;": "\u22F5\u0338",
+        "notinE;": "\u22F9\u0338",
+        "notinva;": "\u2209",
+        "notinvb;": "\u22F7",
+        "notinvc;": "\u22F6",
+        "NotLeftTriangle;": "\u22EA",
+        "NotLeftTriangleBar;": "\u29CF\u0338",
+        "NotLeftTriangleEqual;": "\u22EC",
+        "NotLess;": "\u226E",
+        "NotLessEqual;": "\u2270",
+        "NotLessGreater;": "\u2278",
+        "NotLessLess;": "\u226A\u0338",
+        "NotLessSlantEqual;": "\u2A7D\u0338",
+        "NotLessTilde;": "\u2274",
+        "NotNestedGreaterGreater;": "\u2AA2\u0338",
+        "NotNestedLessLess;": "\u2AA1\u0338",
+        "notni;": "\u220C",
+        "notniva;": "\u220C",
+        "notnivb;": "\u22FE",
+        "notnivc;": "\u22FD",
+        "NotPrecedes;": "\u2280",
+        "NotPrecedesEqual;": "\u2AAF\u0338",
+        "NotPrecedesSlantEqual;": "\u22E0",
+        "NotReverseElement;": "\u220C",
+        "NotRightTriangle;": "\u22EB",
+        "NotRightTriangleBar;": "\u29D0\u0338",
+        "NotRightTriangleEqual;": "\u22ED",
+        "NotSquareSubset;": "\u228F\u0338",
+        "NotSquareSubsetEqual;": "\u22E2",
+        "NotSquareSuperset;": "\u2290\u0338",
+        "NotSquareSupersetEqual;": "\u22E3",
+        "NotSubset;": "\u2282\u20D2",
+        "NotSubsetEqual;": "\u2288",
+        "NotSucceeds;": "\u2281",
+        "NotSucceedsEqual;": "\u2AB0\u0338",
+        "NotSucceedsSlantEqual;": "\u22E1",
+        "NotSucceedsTilde;": "\u227F\u0338",
+        "NotSuperset;": "\u2283\u20D2",
+        "NotSupersetEqual;": "\u2289",
+        "NotTilde;": "\u2241",
+        "NotTildeEqual;": "\u2244",
+        "NotTildeFullEqual;": "\u2247",
+        "NotTildeTilde;": "\u2249",
+        "NotVerticalBar;": "\u2224",
+        "npar;": "\u2226",
+        "nparallel;": "\u2226",
+        "nparsl;": "\u2AFD\u20E5",
+        "npart;": "\u2202\u0338",
+        "npolint;": "\u2A14",
+        "npr;": "\u2280",
+        "nprcue;": "\u22E0",
+        "npre;": "\u2AAF\u0338",
+        "nprec;": "\u2280",
+        "npreceq;": "\u2AAF\u0338",
+        "nrArr;": "\u21CF",
+        "nrarr;": "\u219B",
+        "nrarrc;": "\u2933\u0338",
+        "nrarrw;": "\u219D\u0338",
+        "nRightarrow;": "\u21CF",
+        "nrightarrow;": "\u219B",
+        "nrtri;": "\u22EB",
+        "nrtrie;": "\u22ED",
+        "nsc;": "\u2281",
+        "nsccue;": "\u22E1",
+        "nsce;": "\u2AB0\u0338",
+        "Nscr;": "\uD835\uDCA9",
+        "nscr;": "\uD835\uDCC3",
+        "nshortmid;": "\u2224",
+        "nshortparallel;": "\u2226",
+        "nsim;": "\u2241",
+        "nsime;": "\u2244",
+        "nsimeq;": "\u2244",
+        "nsmid;": "\u2224",
+        "nspar;": "\u2226",
+        "nsqsube;": "\u22E2",
+        "nsqsupe;": "\u22E3",
+        "nsub;": "\u2284",
+        "nsubE;": "\u2AC5\u0338",
+        "nsube;": "\u2288",
+        "nsubset;": "\u2282\u20D2",
+        "nsubseteq;": "\u2288",
+        "nsubseteqq;": "\u2AC5\u0338",
+        "nsucc;": "\u2281",
+        "nsucceq;": "\u2AB0\u0338",
+        "nsup;": "\u2285",
+        "nsupE;": "\u2AC6\u0338",
+        "nsupe;": "\u2289",
+        "nsupset;": "\u2283\u20D2",
+        "nsupseteq;": "\u2289",
+        "nsupseteqq;": "\u2AC6\u0338",
+        "ntgl;": "\u2279",
+        "Ntilde;": "\u00D1",
+        "Ntilde": "\u00D1",
+        "ntilde;": "\u00F1",
+        "ntilde": "\u00F1",
+        "ntlg;": "\u2278",
+        "ntriangleleft;": "\u22EA",
+        "ntrianglelefteq;": "\u22EC",
+        "ntriangleright;": "\u22EB",
+        "ntrianglerighteq;": "\u22ED",
+        "Nu;": "\u039D",
+        "nu;": "\u03BD",
+        "num;": "\u0023",
+        "numero;": "\u2116",
+        "numsp;": "\u2007",
+        "nvap;": "\u224D\u20D2",
+        "nVDash;": "\u22AF",
+        "nVdash;": "\u22AE",
+        "nvDash;": "\u22AD",
+        "nvdash;": "\u22AC",
+        "nvge;": "\u2265\u20D2",
+        "nvgt;": "\u003E\u20D2",
+        "nvHarr;": "\u2904",
+        "nvinfin;": "\u29DE",
+        "nvlArr;": "\u2902",
+        "nvle;": "\u2264\u20D2",
+        "nvlt;": "\u003C\u20D2",
+        "nvltrie;": "\u22B4\u20D2",
+        "nvrArr;": "\u2903",
+        "nvrtrie;": "\u22B5\u20D2",
+        "nvsim;": "\u223C\u20D2",
+        "nwarhk;": "\u2923",
+        "nwArr;": "\u21D6",
+        "nwarr;": "\u2196",
+        "nwarrow;": "\u2196",
+        "nwnear;": "\u2927",
+        "Oacute;": "\u00D3",
+        "Oacute": "\u00D3",
+        "oacute;": "\u00F3",
+        "oacute": "\u00F3",
+        "oast;": "\u229B",
+        "ocir;": "\u229A",
+        "Ocirc;": "\u00D4",
+        "Ocirc": "\u00D4",
+        "ocirc;": "\u00F4",
+        "ocirc": "\u00F4",
+        "Ocy;": "\u041E",
+        "ocy;": "\u043E",
+        "odash;": "\u229D",
+        "Odblac;": "\u0150",
+        "odblac;": "\u0151",
+        "odiv;": "\u2A38",
+        "odot;": "\u2299",
+        "odsold;": "\u29BC",
+        "OElig;": "\u0152",
+        "oelig;": "\u0153",
+        "ofcir;": "\u29BF",
+        "Ofr;": "\uD835\uDD12",
+        "ofr;": "\uD835\uDD2C",
+        "ogon;": "\u02DB",
+        "Ograve;": "\u00D2",
+        "Ograve": "\u00D2",
+        "ograve;": "\u00F2",
+        "ograve": "\u00F2",
+        "ogt;": "\u29C1",
+        "ohbar;": "\u29B5",
+        "ohm;": "\u03A9",
+        "oint;": "\u222E",
+        "olarr;": "\u21BA",
+        "olcir;": "\u29BE",
+        "olcross;": "\u29BB",
+        "oline;": "\u203E",
+        "olt;": "\u29C0",
+        "Omacr;": "\u014C",
+        "omacr;": "\u014D",
+        "Omega;": "\u03A9",
+        "omega;": "\u03C9",
+        "Omicron;": "\u039F",
+        "omicron;": "\u03BF",
+        "omid;": "\u29B6",
+        "ominus;": "\u2296",
+        "Oopf;": "\uD835\uDD46",
+        "oopf;": "\uD835\uDD60",
+        "opar;": "\u29B7",
+        "OpenCurlyDoubleQuote;": "\u201C",
+        "OpenCurlyQuote;": "\u2018",
+        "operp;": "\u29B9",
+        "oplus;": "\u2295",
+        "Or;": "\u2A54",
+        "or;": "\u2228",
+        "orarr;": "\u21BB",
+        "ord;": "\u2A5D",
+        "order;": "\u2134",
+        "orderof;": "\u2134",
+        "ordf;": "\u00AA",
+        "ordf": "\u00AA",
+        "ordm;": "\u00BA",
+        "ordm": "\u00BA",
+        "origof;": "\u22B6",
+        "oror;": "\u2A56",
+        "orslope;": "\u2A57",
+        "orv;": "\u2A5B",
+        "oS;": "\u24C8",
+        "Oscr;": "\uD835\uDCAA",
+        "oscr;": "\u2134",
+        "Oslash;": "\u00D8",
+        "Oslash": "\u00D8",
+        "oslash;": "\u00F8",
+        "oslash": "\u00F8",
+        "osol;": "\u2298",
+        "Otilde;": "\u00D5",
+        "Otilde": "\u00D5",
+        "otilde;": "\u00F5",
+        "otilde": "\u00F5",
+        "Otimes;": "\u2A37",
+        "otimes;": "\u2297",
+        "otimesas;": "\u2A36",
+        "Ouml;": "\u00D6",
+        "Ouml": "\u00D6",
+        "ouml;": "\u00F6",
+        "ouml": "\u00F6",
+        "ovbar;": "\u233D",
+        "OverBar;": "\u203E",
+        "OverBrace;": "\u23DE",
+        "OverBracket;": "\u23B4",
+        "OverParenthesis;": "\u23DC",
+        "par;": "\u2225",
+        "para;": "\u00B6",
+        "para": "\u00B6",
+        "parallel;": "\u2225",
+        "parsim;": "\u2AF3",
+        "parsl;": "\u2AFD",
+        "part;": "\u2202",
+        "PartialD;": "\u2202",
+        "Pcy;": "\u041F",
+        "pcy;": "\u043F",
+        "percnt;": "\u0025",
+        "period;": "\u002E",
+        "permil;": "\u2030",
+        "perp;": "\u22A5",
+        "pertenk;": "\u2031",
+        "Pfr;": "\uD835\uDD13",
+        "pfr;": "\uD835\uDD2D",
+        "Phi;": "\u03A6",
+        "phi;": "\u03C6",
+        "phiv;": "\u03D5",
+        "phmmat;": "\u2133",
+        "phone;": "\u260E",
+        "Pi;": "\u03A0",
+        "pi;": "\u03C0",
+        "pitchfork;": "\u22D4",
+        "piv;": "\u03D6",
+        "planck;": "\u210F",
+        "planckh;": "\u210E",
+        "plankv;": "\u210F",
+        "plus;": "\u002B",
+        "plusacir;": "\u2A23",
+        "plusb;": "\u229E",
+        "pluscir;": "\u2A22",
+        "plusdo;": "\u2214",
+        "plusdu;": "\u2A25",
+        "pluse;": "\u2A72",
+        "PlusMinus;": "\u00B1",
+        "plusmn;": "\u00B1",
+        "plusmn": "\u00B1",
+        "plussim;": "\u2A26",
+        "plustwo;": "\u2A27",
+        "pm;": "\u00B1",
+        "Poincareplane;": "\u210C",
+        "pointint;": "\u2A15",
+        "Popf;": "\u2119",
+        "popf;": "\uD835\uDD61",
+        "pound;": "\u00A3",
+        "pound": "\u00A3",
+        "Pr;": "\u2ABB",
+        "pr;": "\u227A",
+        "prap;": "\u2AB7",
+        "prcue;": "\u227C",
+        "prE;": "\u2AB3",
+        "pre;": "\u2AAF",
+        "prec;": "\u227A",
+        "precapprox;": "\u2AB7",
+        "preccurlyeq;": "\u227C",
+        "Precedes;": "\u227A",
+        "PrecedesEqual;": "\u2AAF",
+        "PrecedesSlantEqual;": "\u227C",
+        "PrecedesTilde;": "\u227E",
+        "preceq;": "\u2AAF",
+        "precnapprox;": "\u2AB9",
+        "precneqq;": "\u2AB5",
+        "precnsim;": "\u22E8",
+        "precsim;": "\u227E",
+        "Prime;": "\u2033",
+        "prime;": "\u2032",
+        "primes;": "\u2119",
+        "prnap;": "\u2AB9",
+        "prnE;": "\u2AB5",
+        "prnsim;": "\u22E8",
+        "prod;": "\u220F",
+        "Product;": "\u220F",
+        "profalar;": "\u232E",
+        "profline;": "\u2312",
+        "profsurf;": "\u2313",
+        "prop;": "\u221D",
+        "Proportion;": "\u2237",
+        "Proportional;": "\u221D",
+        "propto;": "\u221D",
+        "prsim;": "\u227E",
+        "prurel;": "\u22B0",
+        "Pscr;": "\uD835\uDCAB",
+        "pscr;": "\uD835\uDCC5",
+        "Psi;": "\u03A8",
+        "psi;": "\u03C8",
+        "puncsp;": "\u2008",
+        "Qfr;": "\uD835\uDD14",
+        "qfr;": "\uD835\uDD2E",
+        "qint;": "\u2A0C",
+        "Qopf;": "\u211A",
+        "qopf;": "\uD835\uDD62",
+        "qprime;": "\u2057",
+        "Qscr;": "\uD835\uDCAC",
+        "qscr;": "\uD835\uDCC6",
+        "quaternions;": "\u210D",
+        "quatint;": "\u2A16",
+        "quest;": "\u003F",
+        "questeq;": "\u225F",
+        "QUOT;": "\u0022",
+        "QUOT": "\u0022",
+        "quot;": "\u0022",
+        "quot": "\u0022",
+        "rAarr;": "\u21DB",
+        "race;": "\u223D\u0331",
+        "Racute;": "\u0154",
+        "racute;": "\u0155",
+        "radic;": "\u221A",
+        "raemptyv;": "\u29B3",
+        "Rang;": "\u27EB",
+        "rang;": "\u27E9",
+        "rangd;": "\u2992",
+        "range;": "\u29A5",
+        "rangle;": "\u27E9",
+        "raquo;": "\u00BB",
+        "raquo": "\u00BB",
+        "Rarr;": "\u21A0",
+        "rArr;": "\u21D2",
+        "rarr;": "\u2192",
+        "rarrap;": "\u2975",
+        "rarrb;": "\u21E5",
+        "rarrbfs;": "\u2920",
+        "rarrc;": "\u2933",
+        "rarrfs;": "\u291E",
+        "rarrhk;": "\u21AA",
+        "rarrlp;": "\u21AC",
+        "rarrpl;": "\u2945",
+        "rarrsim;": "\u2974",
+        "Rarrtl;": "\u2916",
+        "rarrtl;": "\u21A3",
+        "rarrw;": "\u219D",
+        "rAtail;": "\u291C",
+        "ratail;": "\u291A",
+        "ratio;": "\u2236",
+        "rationals;": "\u211A",
+        "RBarr;": "\u2910",
+        "rBarr;": "\u290F",
+        "rbarr;": "\u290D",
+        "rbbrk;": "\u2773",
+        "rbrace;": "\u007D",
+        "rbrack;": "\u005D",
+        "rbrke;": "\u298C",
+        "rbrksld;": "\u298E",
+        "rbrkslu;": "\u2990",
+        "Rcaron;": "\u0158",
+        "rcaron;": "\u0159",
+        "Rcedil;": "\u0156",
+        "rcedil;": "\u0157",
+        "rceil;": "\u2309",
+        "rcub;": "\u007D",
+        "Rcy;": "\u0420",
+        "rcy;": "\u0440",
+        "rdca;": "\u2937",
+        "rdldhar;": "\u2969",
+        "rdquo;": "\u201D",
+        "rdquor;": "\u201D",
+        "rdsh;": "\u21B3",
+        "Re;": "\u211C",
+        "real;": "\u211C",
+        "realine;": "\u211B",
+        "realpart;": "\u211C",
+        "reals;": "\u211D",
+        "rect;": "\u25AD",
+        "REG;": "\u00AE",
+        "REG": "\u00AE",
+        "reg;": "\u00AE",
+        "reg": "\u00AE",
+        "ReverseElement;": "\u220B",
+        "ReverseEquilibrium;": "\u21CB",
+        "ReverseUpEquilibrium;": "\u296F",
+        "rfisht;": "\u297D",
+        "rfloor;": "\u230B",
+        "Rfr;": "\u211C",
+        "rfr;": "\uD835\uDD2F",
+        "rHar;": "\u2964",
+        "rhard;": "\u21C1",
+        "rharu;": "\u21C0",
+        "rharul;": "\u296C",
+        "Rho;": "\u03A1",
+        "rho;": "\u03C1",
+        "rhov;": "\u03F1",
+        "RightAngleBracket;": "\u27E9",
+        "RightArrow;": "\u2192",
+        "Rightarrow;": "\u21D2",
+        "rightarrow;": "\u2192",
+        "RightArrowBar;": "\u21E5",
+        "RightArrowLeftArrow;": "\u21C4",
+        "rightarrowtail;": "\u21A3",
+        "RightCeiling;": "\u2309",
+        "RightDoubleBracket;": "\u27E7",
+        "RightDownTeeVector;": "\u295D",
+        "RightDownVector;": "\u21C2",
+        "RightDownVectorBar;": "\u2955",
+        "RightFloor;": "\u230B",
+        "rightharpoondown;": "\u21C1",
+        "rightharpoonup;": "\u21C0",
+        "rightleftarrows;": "\u21C4",
+        "rightleftharpoons;": "\u21CC",
+        "rightrightarrows;": "\u21C9",
+        "rightsquigarrow;": "\u219D",
+        "RightTee;": "\u22A2",
+        "RightTeeArrow;": "\u21A6",
+        "RightTeeVector;": "\u295B",
+        "rightthreetimes;": "\u22CC",
+        "RightTriangle;": "\u22B3",
+        "RightTriangleBar;": "\u29D0",
+        "RightTriangleEqual;": "\u22B5",
+        "RightUpDownVector;": "\u294F",
+        "RightUpTeeVector;": "\u295C",
+        "RightUpVector;": "\u21BE",
+        "RightUpVectorBar;": "\u2954",
+        "RightVector;": "\u21C0",
+        "RightVectorBar;": "\u2953",
+        "ring;": "\u02DA",
+        "risingdotseq;": "\u2253",
+        "rlarr;": "\u21C4",
+        "rlhar;": "\u21CC",
+        "rlm;": "\u200F",
+        "rmoust;": "\u23B1",
+        "rmoustache;": "\u23B1",
+        "rnmid;": "\u2AEE",
+        "roang;": "\u27ED",
+        "roarr;": "\u21FE",
+        "robrk;": "\u27E7",
+        "ropar;": "\u2986",
+        "Ropf;": "\u211D",
+        "ropf;": "\uD835\uDD63",
+        "roplus;": "\u2A2E",
+        "rotimes;": "\u2A35",
+        "RoundImplies;": "\u2970",
+        "rpar;": "\u0029",
+        "rpargt;": "\u2994",
+        "rppolint;": "\u2A12",
+        "rrarr;": "\u21C9",
+        "Rrightarrow;": "\u21DB",
+        "rsaquo;": "\u203A",
+        "Rscr;": "\u211B",
+        "rscr;": "\uD835\uDCC7",
+        "Rsh;": "\u21B1",
+        "rsh;": "\u21B1",
+        "rsqb;": "\u005D",
+        "rsquo;": "\u2019",
+        "rsquor;": "\u2019",
+        "rthree;": "\u22CC",
+        "rtimes;": "\u22CA",
+        "rtri;": "\u25B9",
+        "rtrie;": "\u22B5",
+        "rtrif;": "\u25B8",
+        "rtriltri;": "\u29CE",
+        "RuleDelayed;": "\u29F4",
+        "ruluhar;": "\u2968",
+        "rx;": "\u211E",
+        "Sacute;": "\u015A",
+        "sacute;": "\u015B",
+        "sbquo;": "\u201A",
+        "Sc;": "\u2ABC",
+        "sc;": "\u227B",
+        "scap;": "\u2AB8",
+        "Scaron;": "\u0160",
+        "scaron;": "\u0161",
+        "sccue;": "\u227D",
+        "scE;": "\u2AB4",
+        "sce;": "\u2AB0",
+        "Scedil;": "\u015E",
+        "scedil;": "\u015F",
+        "Scirc;": "\u015C",
+        "scirc;": "\u015D",
+        "scnap;": "\u2ABA",
+        "scnE;": "\u2AB6",
+        "scnsim;": "\u22E9",
+        "scpolint;": "\u2A13",
+        "scsim;": "\u227F",
+        "Scy;": "\u0421",
+        "scy;": "\u0441",
+        "sdot;": "\u22C5",
+        "sdotb;": "\u22A1",
+        "sdote;": "\u2A66",
+        "searhk;": "\u2925",
+        "seArr;": "\u21D8",
+        "searr;": "\u2198",
+        "searrow;": "\u2198",
+        "sect;": "\u00A7",
+        "sect": "\u00A7",
+        "semi;": "\u003B",
+        "seswar;": "\u2929",
+        "setminus;": "\u2216",
+        "setmn;": "\u2216",
+        "sext;": "\u2736",
+        "Sfr;": "\uD835\uDD16",
+        "sfr;": "\uD835\uDD30",
+        "sfrown;": "\u2322",
+        "sharp;": "\u266F",
+        "SHCHcy;": "\u0429",
+        "shchcy;": "\u0449",
+        "SHcy;": "\u0428",
+        "shcy;": "\u0448",
+        "ShortDownArrow;": "\u2193",
+        "ShortLeftArrow;": "\u2190",
+        "shortmid;": "\u2223",
+        "shortparallel;": "\u2225",
+        "ShortRightArrow;": "\u2192",
+        "ShortUpArrow;": "\u2191",
+        "shy;": "\u00AD",
+        "shy": "\u00AD",
+        "Sigma;": "\u03A3",
+        "sigma;": "\u03C3",
+        "sigmaf;": "\u03C2",
+        "sigmav;": "\u03C2",
+        "sim;": "\u223C",
+        "simdot;": "\u2A6A",
+        "sime;": "\u2243",
+        "simeq;": "\u2243",
+        "simg;": "\u2A9E",
+        "simgE;": "\u2AA0",
+        "siml;": "\u2A9D",
+        "simlE;": "\u2A9F",
+        "simne;": "\u2246",
+        "simplus;": "\u2A24",
+        "simrarr;": "\u2972",
+        "slarr;": "\u2190",
+        "SmallCircle;": "\u2218",
+        "smallsetminus;": "\u2216",
+        "smashp;": "\u2A33",
+        "smeparsl;": "\u29E4",
+        "smid;": "\u2223",
+        "smile;": "\u2323",
+        "smt;": "\u2AAA",
+        "smte;": "\u2AAC",
+        "smtes;": "\u2AAC\uFE00",
+        "SOFTcy;": "\u042C",
+        "softcy;": "\u044C",
+        "sol;": "\u002F",
+        "solb;": "\u29C4",
+        "solbar;": "\u233F",
+        "Sopf;": "\uD835\uDD4A",
+        "sopf;": "\uD835\uDD64",
+        "spades;": "\u2660",
+        "spadesuit;": "\u2660",
+        "spar;": "\u2225",
+        "sqcap;": "\u2293",
+        "sqcaps;": "\u2293\uFE00",
+        "sqcup;": "\u2294",
+        "sqcups;": "\u2294\uFE00",
+        "Sqrt;": "\u221A",
+        "sqsub;": "\u228F",
+        "sqsube;": "\u2291",
+        "sqsubset;": "\u228F",
+        "sqsubseteq;": "\u2291",
+        "sqsup;": "\u2290",
+        "sqsupe;": "\u2292",
+        "sqsupset;": "\u2290",
+        "sqsupseteq;": "\u2292",
+        "squ;": "\u25A1",
+        "Square;": "\u25A1",
+        "square;": "\u25A1",
+        "SquareIntersection;": "\u2293",
+        "SquareSubset;": "\u228F",
+        "SquareSubsetEqual;": "\u2291",
+        "SquareSuperset;": "\u2290",
+        "SquareSupersetEqual;": "\u2292",
+        "SquareUnion;": "\u2294",
+        "squarf;": "\u25AA",
+        "squf;": "\u25AA",
+        "srarr;": "\u2192",
+        "Sscr;": "\uD835\uDCAE",
+        "sscr;": "\uD835\uDCC8",
+        "ssetmn;": "\u2216",
+        "ssmile;": "\u2323",
+        "sstarf;": "\u22C6",
+        "Star;": "\u22C6",
+        "star;": "\u2606",
+        "starf;": "\u2605",
+        "straightepsilon;": "\u03F5",
+        "straightphi;": "\u03D5",
+        "strns;": "\u00AF",
+        "Sub;": "\u22D0",
+        "sub;": "\u2282",
+        "subdot;": "\u2ABD",
+        "subE;": "\u2AC5",
+        "sube;": "\u2286",
+        "subedot;": "\u2AC3",
+        "submult;": "\u2AC1",
+        "subnE;": "\u2ACB",
+        "subne;": "\u228A",
+        "subplus;": "\u2ABF",
+        "subrarr;": "\u2979",
+        "Subset;": "\u22D0",
+        "subset;": "\u2282",
+        "subseteq;": "\u2286",
+        "subseteqq;": "\u2AC5",
+        "SubsetEqual;": "\u2286",
+        "subsetneq;": "\u228A",
+        "subsetneqq;": "\u2ACB",
+        "subsim;": "\u2AC7",
+        "subsub;": "\u2AD5",
+        "subsup;": "\u2AD3",
+        "succ;": "\u227B",
+        "succapprox;": "\u2AB8",
+        "succcurlyeq;": "\u227D",
+        "Succeeds;": "\u227B",
+        "SucceedsEqual;": "\u2AB0",
+        "SucceedsSlantEqual;": "\u227D",
+        "SucceedsTilde;": "\u227F",
+        "succeq;": "\u2AB0",
+        "succnapprox;": "\u2ABA",
+        "succneqq;": "\u2AB6",
+        "succnsim;": "\u22E9",
+        "succsim;": "\u227F",
+        "SuchThat;": "\u220B",
+        "Sum;": "\u2211",
+        "sum;": "\u2211",
+        "sung;": "\u266A",
+        "Sup;": "\u22D1",
+        "sup;": "\u2283",
+        "sup1;": "\u00B9",
+        "sup1": "\u00B9",
+        "sup2;": "\u00B2",
+        "sup2": "\u00B2",
+        "sup3;": "\u00B3",
+        "sup3": "\u00B3",
+        "supdot;": "\u2ABE",
+        "supdsub;": "\u2AD8",
+        "supE;": "\u2AC6",
+        "supe;": "\u2287",
+        "supedot;": "\u2AC4",
+        "Superset;": "\u2283",
+        "SupersetEqual;": "\u2287",
+        "suphsol;": "\u27C9",
+        "suphsub;": "\u2AD7",
+        "suplarr;": "\u297B",
+        "supmult;": "\u2AC2",
+        "supnE;": "\u2ACC",
+        "supne;": "\u228B",
+        "supplus;": "\u2AC0",
+        "Supset;": "\u22D1",
+        "supset;": "\u2283",
+        "supseteq;": "\u2287",
+        "supseteqq;": "\u2AC6",
+        "supsetneq;": "\u228B",
+        "supsetneqq;": "\u2ACC",
+        "supsim;": "\u2AC8",
+        "supsub;": "\u2AD4",
+        "supsup;": "\u2AD6",
+        "swarhk;": "\u2926",
+        "swArr;": "\u21D9",
+        "swarr;": "\u2199",
+        "swarrow;": "\u2199",
+        "swnwar;": "\u292A",
+        "szlig;": "\u00DF",
+        "szlig": "\u00DF",
+        "Tab;": "\u0009",
+        "target;": "\u2316",
+        "Tau;": "\u03A4",
+        "tau;": "\u03C4",
+        "tbrk;": "\u23B4",
+        "Tcaron;": "\u0164",
+        "tcaron;": "\u0165",
+        "Tcedil;": "\u0162",
+        "tcedil;": "\u0163",
+        "Tcy;": "\u0422",
+        "tcy;": "\u0442",
+        "tdot;": "\u20DB",
+        "telrec;": "\u2315",
+        "Tfr;": "\uD835\uDD17",
+        "tfr;": "\uD835\uDD31",
+        "there4;": "\u2234",
+        "Therefore;": "\u2234",
+        "therefore;": "\u2234",
+        "Theta;": "\u0398",
+        "theta;": "\u03B8",
+        "thetasym;": "\u03D1",
+        "thetav;": "\u03D1",
+        "thickapprox;": "\u2248",
+        "thicksim;": "\u223C",
+        "ThickSpace;": "\u205F\u200A",
+        "thinsp;": "\u2009",
+        "ThinSpace;": "\u2009",
+        "thkap;": "\u2248",
+        "thksim;": "\u223C",
+        "THORN;": "\u00DE",
+        "THORN": "\u00DE",
+        "thorn;": "\u00FE",
+        "thorn": "\u00FE",
+        "Tilde;": "\u223C",
+        "tilde;": "\u02DC",
+        "TildeEqual;": "\u2243",
+        "TildeFullEqual;": "\u2245",
+        "TildeTilde;": "\u2248",
+        "times;": "\u00D7",
+        "times": "\u00D7",
+        "timesb;": "\u22A0",
+        "timesbar;": "\u2A31",
+        "timesd;": "\u2A30",
+        "tint;": "\u222D",
+        "toea;": "\u2928",
+        "top;": "\u22A4",
+        "topbot;": "\u2336",
+        "topcir;": "\u2AF1",
+        "Topf;": "\uD835\uDD4B",
+        "topf;": "\uD835\uDD65",
+        "topfork;": "\u2ADA",
+        "tosa;": "\u2929",
+        "tprime;": "\u2034",
+        "TRADE;": "\u2122",
+        "trade;": "\u2122",
+        "triangle;": "\u25B5",
+        "triangledown;": "\u25BF",
+        "triangleleft;": "\u25C3",
+        "trianglelefteq;": "\u22B4",
+        "triangleq;": "\u225C",
+        "triangleright;": "\u25B9",
+        "trianglerighteq;": "\u22B5",
+        "tridot;": "\u25EC",
+        "trie;": "\u225C",
+        "triminus;": "\u2A3A",
+        "TripleDot;": "\u20DB",
+        "triplus;": "\u2A39",
+        "trisb;": "\u29CD",
+        "tritime;": "\u2A3B",
+        "trpezium;": "\u23E2",
+        "Tscr;": "\uD835\uDCAF",
+        "tscr;": "\uD835\uDCC9",
+        "TScy;": "\u0426",
+        "tscy;": "\u0446",
+        "TSHcy;": "\u040B",
+        "tshcy;": "\u045B",
+        "Tstrok;": "\u0166",
+        "tstrok;": "\u0167",
+        "twixt;": "\u226C",
+        "twoheadleftarrow;": "\u219E",
+        "twoheadrightarrow;": "\u21A0",
+        "Uacute;": "\u00DA",
+        "Uacute": "\u00DA",
+        "uacute;": "\u00FA",
+        "uacute": "\u00FA",
+        "Uarr;": "\u219F",
+        "uArr;": "\u21D1",
+        "uarr;": "\u2191",
+        "Uarrocir;": "\u2949",
+        "Ubrcy;": "\u040E",
+        "ubrcy;": "\u045E",
+        "Ubreve;": "\u016C",
+        "ubreve;": "\u016D",
+        "Ucirc;": "\u00DB",
+        "Ucirc": "\u00DB",
+        "ucirc;": "\u00FB",
+        "ucirc": "\u00FB",
+        "Ucy;": "\u0423",
+        "ucy;": "\u0443",
+        "udarr;": "\u21C5",
+        "Udblac;": "\u0170",
+        "udblac;": "\u0171",
+        "udhar;": "\u296E",
+        "ufisht;": "\u297E",
+        "Ufr;": "\uD835\uDD18",
+        "ufr;": "\uD835\uDD32",
+        "Ugrave;": "\u00D9",
+        "Ugrave": "\u00D9",
+        "ugrave;": "\u00F9",
+        "ugrave": "\u00F9",
+        "uHar;": "\u2963",
+        "uharl;": "\u21BF",
+        "uharr;": "\u21BE",
+        "uhblk;": "\u2580",
+        "ulcorn;": "\u231C",
+        "ulcorner;": "\u231C",
+        "ulcrop;": "\u230F",
+        "ultri;": "\u25F8",
+        "Umacr;": "\u016A",
+        "umacr;": "\u016B",
+        "uml;": "\u00A8",
+        "uml": "\u00A8",
+        "UnderBar;": "\u005F",
+        "UnderBrace;": "\u23DF",
+        "UnderBracket;": "\u23B5",
+        "UnderParenthesis;": "\u23DD",
+        "Union;": "\u22C3",
+        "UnionPlus;": "\u228E",
+        "Uogon;": "\u0172",
+        "uogon;": "\u0173",
+        "Uopf;": "\uD835\uDD4C",
+        "uopf;": "\uD835\uDD66",
+        "UpArrow;": "\u2191",
+        "Uparrow;": "\u21D1",
+        "uparrow;": "\u2191",
+        "UpArrowBar;": "\u2912",
+        "UpArrowDownArrow;": "\u21C5",
+        "UpDownArrow;": "\u2195",
+        "Updownarrow;": "\u21D5",
+        "updownarrow;": "\u2195",
+        "UpEquilibrium;": "\u296E",
+        "upharpoonleft;": "\u21BF",
+        "upharpoonright;": "\u21BE",
+        "uplus;": "\u228E",
+        "UpperLeftArrow;": "\u2196",
+        "UpperRightArrow;": "\u2197",
+        "Upsi;": "\u03D2",
+        "upsi;": "\u03C5",
+        "upsih;": "\u03D2",
+        "Upsilon;": "\u03A5",
+        "upsilon;": "\u03C5",
+        "UpTee;": "\u22A5",
+        "UpTeeArrow;": "\u21A5",
+        "upuparrows;": "\u21C8",
+        "urcorn;": "\u231D",
+        "urcorner;": "\u231D",
+        "urcrop;": "\u230E",
+        "Uring;": "\u016E",
+        "uring;": "\u016F",
+        "urtri;": "\u25F9",
+        "Uscr;": "\uD835\uDCB0",
+        "uscr;": "\uD835\uDCCA",
+        "utdot;": "\u22F0",
+        "Utilde;": "\u0168",
+        "utilde;": "\u0169",
+        "utri;": "\u25B5",
+        "utrif;": "\u25B4",
+        "uuarr;": "\u21C8",
+        "Uuml;": "\u00DC",
+        "Uuml": "\u00DC",
+        "uuml;": "\u00FC",
+        "uuml": "\u00FC",
+        "uwangle;": "\u29A7",
+        "vangrt;": "\u299C",
+        "varepsilon;": "\u03F5",
+        "varkappa;": "\u03F0",
+        "varnothing;": "\u2205",
+        "varphi;": "\u03D5",
+        "varpi;": "\u03D6",
+        "varpropto;": "\u221D",
+        "vArr;": "\u21D5",
+        "varr;": "\u2195",
+        "varrho;": "\u03F1",
+        "varsigma;": "\u03C2",
+        "varsubsetneq;": "\u228A\uFE00",
+        "varsubsetneqq;": "\u2ACB\uFE00",
+        "varsupsetneq;": "\u228B\uFE00",
+        "varsupsetneqq;": "\u2ACC\uFE00",
+        "vartheta;": "\u03D1",
+        "vartriangleleft;": "\u22B2",
+        "vartriangleright;": "\u22B3",
+        "Vbar;": "\u2AEB",
+        "vBar;": "\u2AE8",
+        "vBarv;": "\u2AE9",
+        "Vcy;": "\u0412",
+        "vcy;": "\u0432",
+        "VDash;": "\u22AB",
+        "Vdash;": "\u22A9",
+        "vDash;": "\u22A8",
+        "vdash;": "\u22A2",
+        "Vdashl;": "\u2AE6",
+        "Vee;": "\u22C1",
+        "vee;": "\u2228",
+        "veebar;": "\u22BB",
+        "veeeq;": "\u225A",
+        "vellip;": "\u22EE",
+        "Verbar;": "\u2016",
+        "verbar;": "\u007C",
+        "Vert;": "\u2016",
+        "vert;": "\u007C",
+        "VerticalBar;": "\u2223",
+        "VerticalLine;": "\u007C",
+        "VerticalSeparator;": "\u2758",
+        "VerticalTilde;": "\u2240",
+        "VeryThinSpace;": "\u200A",
+        "Vfr;": "\uD835\uDD19",
+        "vfr;": "\uD835\uDD33",
+        "vltri;": "\u22B2",
+        "vnsub;": "\u2282\u20D2",
+        "vnsup;": "\u2283\u20D2",
+        "Vopf;": "\uD835\uDD4D",
+        "vopf;": "\uD835\uDD67",
+        "vprop;": "\u221D",
+        "vrtri;": "\u22B3",
+        "Vscr;": "\uD835\uDCB1",
+        "vscr;": "\uD835\uDCCB",
+        "vsubnE;": "\u2ACB\uFE00",
+        "vsubne;": "\u228A\uFE00",
+        "vsupnE;": "\u2ACC\uFE00",
+        "vsupne;": "\u228B\uFE00",
+        "Vvdash;": "\u22AA",
+        "vzigzag;": "\u299A",
+        "Wcirc;": "\u0174",
+        "wcirc;": "\u0175",
+        "wedbar;": "\u2A5F",
+        "Wedge;": "\u22C0",
+        "wedge;": "\u2227",
+        "wedgeq;": "\u2259",
+        "weierp;": "\u2118",
+        "Wfr;": "\uD835\uDD1A",
+        "wfr;": "\uD835\uDD34",
+        "Wopf;": "\uD835\uDD4E",
+        "wopf;": "\uD835\uDD68",
+        "wp;": "\u2118",
+        "wr;": "\u2240",
+        "wreath;": "\u2240",
+        "Wscr;": "\uD835\uDCB2",
+        "wscr;": "\uD835\uDCCC",
+        "xcap;": "\u22C2",
+        "xcirc;": "\u25EF",
+        "xcup;": "\u22C3",
+        "xdtri;": "\u25BD",
+        "Xfr;": "\uD835\uDD1B",
+        "xfr;": "\uD835\uDD35",
+        "xhArr;": "\u27FA",
+        "xharr;": "\u27F7",
+        "Xi;": "\u039E",
+        "xi;": "\u03BE",
+        "xlArr;": "\u27F8",
+        "xlarr;": "\u27F5",
+        "xmap;": "\u27FC",
+        "xnis;": "\u22FB",
+        "xodot;": "\u2A00",
+        "Xopf;": "\uD835\uDD4F",
+        "xopf;": "\uD835\uDD69",
+        "xoplus;": "\u2A01",
+        "xotime;": "\u2A02",
+        "xrArr;": "\u27F9",
+        "xrarr;": "\u27F6",
+        "Xscr;": "\uD835\uDCB3",
+        "xscr;": "\uD835\uDCCD",
+        "xsqcup;": "\u2A06",
+        "xuplus;": "\u2A04",
+        "xutri;": "\u25B3",
+        "xvee;": "\u22C1",
+        "xwedge;": "\u22C0",
+        "Yacute;": "\u00DD",
+        "Yacute": "\u00DD",
+        "yacute;": "\u00FD",
+        "yacute": "\u00FD",
+        "YAcy;": "\u042F",
+        "yacy;": "\u044F",
+        "Ycirc;": "\u0176",
+        "ycirc;": "\u0177",
+        "Ycy;": "\u042B",
+        "ycy;": "\u044B",
+        "yen;": "\u00A5",
+        "yen": "\u00A5",
+        "Yfr;": "\uD835\uDD1C",
+        "yfr;": "\uD835\uDD36",
+        "YIcy;": "\u0407",
+        "yicy;": "\u0457",
+        "Yopf;": "\uD835\uDD50",
+        "yopf;": "\uD835\uDD6A",
+        "Yscr;": "\uD835\uDCB4",
+        "yscr;": "\uD835\uDCCE",
+        "YUcy;": "\u042E",
+        "yucy;": "\u044E",
+        "Yuml;": "\u0178",
+        "yuml;": "\u00FF",
+        "yuml": "\u00FF",
+        "Zacute;": "\u0179",
+        "zacute;": "\u017A",
+        "Zcaron;": "\u017D",
+        "zcaron;": "\u017E",
+        "Zcy;": "\u0417",
+        "zcy;": "\u0437",
+        "Zdot;": "\u017B",
+        "zdot;": "\u017C",
+        "zeetrf;": "\u2128",
+        "ZeroWidthSpace;": "\u200B",
+        "Zeta;": "\u0396",
+        "zeta;": "\u03B6",
+        "Zfr;": "\u2128",
+        "zfr;": "\uD835\uDD37",
+        "ZHcy;": "\u0416",
+        "zhcy;": "\u0436",
+        "zigrarr;": "\u21DD",
+        "Zopf;": "\u2124",
+        "zopf;": "\uD835\uDD6B",
+        "Zscr;": "\uD835\uDCB5",
+        "zscr;": "\uD835\uDCCF",
+        "zwj;": "\u200D",
+        "zwnj;": "\u200C"
+    };
+});

Java开发环境安装/eclipse-jee-2024-06-R-win32-x86_64/eclipse/plugins/org.eclipse.wildwebdeveloper_1.2.2.202405280856/node_modules/volar-service-html/node_modules/vscode-html-languageservice/lib/umd/parser/htmlParser.js

@@ -1,3 +1,176 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:1b9ece2bc1a1494b49f825fdf2edc56457b89ed33bf34ca5f80faea5c86cf523
-size 8205
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "./htmlScanner", "../utils/arrays", "../htmlLanguageTypes"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.HTMLParser = exports.Node = void 0;
+    const htmlScanner_1 = require("./htmlScanner");
+    const arrays_1 = require("../utils/arrays");
+    const htmlLanguageTypes_1 = require("../htmlLanguageTypes");
+    class Node {
+        get attributeNames() { return this.attributes ? Object.keys(this.attributes) : []; }
+        constructor(start, end, children, parent) {
+            this.start = start;
+            this.end = end;
+            this.children = children;
+            this.parent = parent;
+            this.closed = false;
+        }
+        isSameTag(tagInLowerCase) {
+            if (this.tag === undefined) {
+                return tagInLowerCase === undefined;
+            }
+            else {
+                return tagInLowerCase !== undefined && this.tag.length === tagInLowerCase.length && this.tag.toLowerCase() === tagInLowerCase;
+            }
+        }
+        get firstChild() { return this.children[0]; }
+        get lastChild() { return this.children.length ? this.children[this.children.length - 1] : void 0; }
+        findNodeBefore(offset) {
+            const idx = (0, arrays_1.findFirst)(this.children, c => offset <= c.start) - 1;
+            if (idx >= 0) {
+                const child = this.children[idx];
+                if (offset > child.start) {
+                    if (offset < child.end) {
+                        return child.findNodeBefore(offset);
+                    }
+                    const lastChild = child.lastChild;
+                    if (lastChild && lastChild.end === child.end) {
+                        return child.findNodeBefore(offset);
+                    }
+                    return child;
+                }
+            }
+            return this;
+        }
+        findNodeAt(offset) {
+            const idx = (0, arrays_1.findFirst)(this.children, c => offset <= c.start) - 1;
+            if (idx >= 0) {
+                const child = this.children[idx];
+                if (offset > child.start && offset <= child.end) {
+                    return child.findNodeAt(offset);
+                }
+            }
+            return this;
+        }
+    }
+    exports.Node = Node;
+    class HTMLParser {
+        constructor(dataManager) {
+            this.dataManager = dataManager;
+        }
+        parseDocument(document) {
+            return this.parse(document.getText(), this.dataManager.getVoidElements(document.languageId));
+        }
+        parse(text, voidElements) {
+            const scanner = (0, htmlScanner_1.createScanner)(text, undefined, undefined, true);
+            const htmlDocument = new Node(0, text.length, [], void 0);
+            let curr = htmlDocument;
+            let endTagStart = -1;
+            let endTagName = undefined;
+            let pendingAttribute = null;
+            let token = scanner.scan();
+            while (token !== htmlLanguageTypes_1.TokenType.EOS) {
+                switch (token) {
+                    case htmlLanguageTypes_1.TokenType.StartTagOpen:
+                        const child = new Node(scanner.getTokenOffset(), text.length, [], curr);
+                        curr.children.push(child);
+                        curr = child;
+                        break;
+                    case htmlLanguageTypes_1.TokenType.StartTag:
+                        curr.tag = scanner.getTokenText();
+                        break;
+                    case htmlLanguageTypes_1.TokenType.StartTagClose:
+                        if (curr.parent) {
+                            curr.end = scanner.getTokenEnd(); // might be later set to end tag position
+                            if (scanner.getTokenLength()) {
+                                curr.startTagEnd = scanner.getTokenEnd();
+                                if (curr.tag && this.dataManager.isVoidElement(curr.tag, voidElements)) {
+                                    curr.closed = true;
+                                    curr = curr.parent;
+                                }
+                            }
+                            else {
+                                // pseudo close token from an incomplete start tag
+                                curr = curr.parent;
+                            }
+                        }
+                        break;
+                    case htmlLanguageTypes_1.TokenType.StartTagSelfClose:
+                        if (curr.parent) {
+                            curr.closed = true;
+                            curr.end = scanner.getTokenEnd();
+                            curr.startTagEnd = scanner.getTokenEnd();
+                            curr = curr.parent;
+                        }
+                        break;
+                    case htmlLanguageTypes_1.TokenType.EndTagOpen:
+                        endTagStart = scanner.getTokenOffset();
+                        endTagName = undefined;
+                        break;
+                    case htmlLanguageTypes_1.TokenType.EndTag:
+                        endTagName = scanner.getTokenText().toLowerCase();
+                        break;
+                    case htmlLanguageTypes_1.TokenType.EndTagClose:
+                        let node = curr;
+                        // see if we can find a matching tag
+                        while (!node.isSameTag(endTagName) && node.parent) {
+                            node = node.parent;
+                        }
+                        if (node.parent) {
+                            while (curr !== node) {
+                                curr.end = endTagStart;
+                                curr.closed = false;
+                                curr = curr.parent;
+                            }
+                            curr.closed = true;
+                            curr.endTagStart = endTagStart;
+                            curr.end = scanner.getTokenEnd();
+                            curr = curr.parent;
+                        }
+                        break;
+                    case htmlLanguageTypes_1.TokenType.AttributeName: {
+                        pendingAttribute = scanner.getTokenText();
+                        let attributes = curr.attributes;
+                        if (!attributes) {
+                            curr.attributes = attributes = {};
+                        }
+                        attributes[pendingAttribute] = null; // Support valueless attributes such as 'checked'
+                        break;
+                    }
+                    case htmlLanguageTypes_1.TokenType.AttributeValue: {
+                        const value = scanner.getTokenText();
+                        const attributes = curr.attributes;
+                        if (attributes && pendingAttribute) {
+                            attributes[pendingAttribute] = value;
+                            pendingAttribute = null;
+                        }
+                        break;
+                    }
+                }
+                token = scanner.scan();
+            }
+            while (curr.parent) {
+                curr.end = text.length;
+                curr.closed = false;
+                curr = curr.parent;
+            }
+            return {
+                roots: htmlDocument.children,
+                findNodeBefore: htmlDocument.findNodeBefore.bind(htmlDocument),
+                findNodeAt: htmlDocument.findNodeAt.bind(htmlDocument)
+            };
+        }
+    }
+    exports.HTMLParser = HTMLParser;
+});