ts-gem-plugin 0.0.11 → 0.0.12

package/dist/index.js

@@ -0,0 +1,2362 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/index.ts
+var import_typescript_template_language_service_decorator = require("@mantou/typescript-template-language-service-decorator");
+
+// ../gem/lib/utils.js
+var { assign, fromEntries, entries, keys } = Object;
+function queueMicrotask(cb) {
+  Promise.resolve().then(cb);
+}
+var microtaskSet = /* @__PURE__ */ new Set();
+function addMicrotask(func, method = queueMicrotask) {
+  if (microtaskSet.has(func))
+    return;
+  method(() => {
+    microtaskSet.delete(func);
+    func();
+  });
+  microtaskSet.add(func);
+}
+function createUpdater(initState, fn) {
+  const state = fn;
+  delete state.name;
+  delete state.length;
+  assign(state, initState);
+  return state;
+}
+var LinkedList = class extends EventTarget {
+  #map = /* @__PURE__ */ new Map();
+  #firstItem;
+  #lastItem;
+  #delete(value) {
+    const existItem = this.#map.get(value);
+    if (existItem) {
+      if (existItem.prev) {
+        existItem.prev.next = existItem.next;
+      } else {
+        this.#firstItem = existItem.next;
+      }
+      if (existItem.next) {
+        existItem.next.prev = existItem.prev;
+      } else {
+        this.#lastItem = existItem.prev;
+      }
+      this.#map.delete(value);
+    }
+    return existItem;
+  }
+  get size() {
+    return this.#map.size;
+  }
+  get first() {
+    return this.#firstItem;
+  }
+  get last() {
+    return this.#lastItem;
+  }
+  isSuperLinkOf(subLink) {
+    let subItem = subLink.first;
+    if (!subItem)
+      return true;
+    let item = this.find(subItem.value);
+    while (item && item.value === subItem.value) {
+      subItem = subItem.next;
+      if (!subItem)
+        return true;
+      item = item.next;
+    }
+    return false;
+  }
+  find(value) {
+    return this.#map.get(value);
+  }
+  /**
+   * 添加到尾部，已存在时会删除老的项目
+   * 如果是添加第一个，start 事件会在添加前触发，避免处理事件重复的逻辑
+   */
+  add(value) {
+    if (!this.#lastItem) {
+      this.dispatchEvent(new CustomEvent("start"));
+    }
+    const item = this.#delete(value) || { value };
+    item.prev = this.#lastItem;
+    if (item.prev) {
+      item.prev.next = item;
+    }
+    item.next = void 0;
+    this.#lastItem = item;
+    if (!this.#firstItem) {
+      this.#firstItem = item;
+    }
+    this.#map.set(value, item);
+  }
+  /** 删除这个元素后没有其他元素时立即出发 end 事件 */
+  delete(value) {
+    const deleteItem = this.#delete(value);
+    if (!this.#firstItem) {
+      this.dispatchEvent(new CustomEvent("end"));
+    }
+    return deleteItem;
+  }
+  clear() {
+    this.#map.clear();
+    this.#firstItem = this.#lastItem = void 0;
+  }
+  /** 获取头部元素，会从链表删除 */
+  get() {
+    const firstItem = this.#firstItem;
+    if (!firstItem)
+      return;
+    this.delete(firstItem.value);
+    return firstItem.value;
+  }
+};
+function camelToKebabCase(str) {
+  return str.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase();
+}
+function kebabToCamelCase(str) {
+  return str.replace(/-(.)/g, (_substr, $1) => $1.toUpperCase());
+}
+
+// ../gem/lib/store.js
+var _StoreListenerMap = /* @__PURE__ */ new WeakMap();
+function createStore(originStore) {
+  const store = createUpdater(originStore, (value) => {
+    Object.assign(store, value);
+    _StoreListenerMap.get(store)?.forEach((func) => addMicrotask(func));
+  });
+  _StoreListenerMap.set(store, /* @__PURE__ */ new Set());
+  return store;
+}
+function connect(store, func) {
+  const listeners = _StoreListenerMap.get(store);
+  listeners?.add(func);
+  return () => listeners?.delete(func);
+}
+
+// src/configuration.ts
+var defaultConfiguration = {
+  strict: false,
+  emmet: {},
+  elementDefineRules: {
+    "Duoyun*Element": "dy-*",
+    "*Element": "*"
+  }
+};
+var Rules = class {
+  #map = /* @__PURE__ */ new Map();
+  constructor(data) {
+    Object.entries(data).forEach(([classNamePattern, tagPattern]) => {
+      this.#map.set(new RegExp(classNamePattern.replace("*", "(.*)")), tagPattern.replace("*", "$1"));
+    });
+  }
+  findTag(className) {
+    for (const [reg, replaceStr] of this.#map) {
+      if (reg.exec(className)) {
+        return camelToKebabCase(className.replace(reg, replaceStr));
+      }
+    }
+  }
+};
+var configurationStore = createStore({});
+function onConfigurationUpdate(fn) {
+  return connect(configurationStore, fn);
+}
+var Configuration = class {
+  strict = defaultConfiguration.strict;
+  emmet = defaultConfiguration.emmet;
+  elementDefineRules = new Rules(defaultConfiguration.elementDefineRules);
+  update({ update, ...config }) {
+    Object.assign(this, defaultConfiguration, config);
+    this.elementDefineRules = new Rules({
+      ...defaultConfiguration.elementDefineRules,
+      ...config.elementDefineRules
+    });
+    configurationStore();
+  }
+};
+
+// src/constants.ts
+var NAME = "gem-plugin";
+var HTML_SUBSTITUTION_CHAR = "_";
+var Decorators = {
+  Attr: "attribute",
+  NumAttr: "numattribute",
+  BoolAttr: "boolattribute",
+  Prop: "property",
+  Emitter: "emitter",
+  GlobalEmitter: "globalemitter",
+  AdoptedStyle: "adoptedStyle",
+  Shadow: "shadow",
+  CustomElement: "customElement",
+  Part: "part",
+  Slot: "slot"
+};
+var Utils = {
+  ClassMap: "classMap",
+  CreateDecoratorTheme: "createDecoratorTheme"
+};
+var Types = {
+  Emitter: "Emitter"
+};
+
+// src/context.ts
+var import_standard_script_source_helper = __toESM(require("@mantou/typescript-template-language-service-decorator/lib/standard-script-source-helper"));
+var import_standard_template_source_helper = __toESM(require("@mantou/typescript-template-language-service-decorator/lib/standard-template-source-helper"));
+var import_vscode_css_languageservice = require("@mantou/vscode-css-languageservice");
+var import_vscode_emmet_helper = require("@mantou/vscode-emmet-helper");
+var import_vscode_html_languageservice2 = require("@mantou/vscode-html-languageservice");
+
+// ../duoyun-ui/lib/map.js
+var StringWeakMap = class {
+  #map = /* @__PURE__ */ new Map();
+  #weakMap = /* @__PURE__ */ new WeakMap();
+  #registry = new FinalizationRegistry((key) => this.#map.delete(key));
+  set(key, val) {
+    this.delete(key);
+    this.#map.set(key, new WeakRef(val));
+    this.#weakMap.set(val, key);
+    this.#registry.register(val, key, val);
+  }
+  get(key) {
+    return this.#map.get(key)?.deref();
+  }
+  findKey(val) {
+    return this.#weakMap.get(val);
+  }
+  delete(key) {
+    const val = this.get(key);
+    if (val) {
+      this.#map.delete(key);
+      this.#weakMap.delete(val);
+      this.#registry.unregister(val);
+    }
+  }
+  *[Symbol.iterator]() {
+    const entries2 = this.#map.entries();
+    for (const [tag, ref] of entries2) {
+      yield [tag, ref.deref()];
+    }
+  }
+};
+
+// ../duoyun-ui/lib/types.js
+function isNullish(v) {
+  return v === null || v === void 0;
+}
+function isNotNullish(v) {
+  return !isNullish(v);
+}
+
+// ../duoyun-ui/lib/cache.js
+var Cache = class {
+  #max;
+  #maxAge;
+  #renewal;
+  #map = /* @__PURE__ */ new Map();
+  #reverseMap = /* @__PURE__ */ new Map();
+  #addedLinked = new LinkedList();
+  constructor({ max = Infinity, maxAge = Infinity, renewal = false } = {}) {
+    this.#max = max;
+    this.#maxAge = maxAge;
+    this.#renewal = renewal;
+  }
+  setOptions(options) {
+    this.#max = options.max ?? this.#max;
+    this.#maxAge = options.maxAge ?? this.#maxAge;
+    this.#renewal = options.renewal ?? this.#renewal;
+  }
+  #trim() {
+    for (let i = this.#addedLinked.size - this.#max; i > 0; i--) {
+      const value = this.#addedLinked.get();
+      const key = this.#reverseMap.get(value);
+      this.#reverseMap.delete(value);
+      this.#map.delete(key);
+    }
+  }
+  set(key, value) {
+    this.#addedLinked.add(value);
+    this.#reverseMap.set(value, key);
+    this.#map.set(key, { value, timestamp: Date.now() });
+    this.#trim();
+    return value;
+  }
+  get(key, init) {
+    const cache = this.#map.get(key);
+    if (!cache) {
+      return init && this.set(key, init(key));
+    }
+    const { timestamp, value } = cache;
+    if (Date.now() - timestamp > this.#maxAge) {
+      this.#addedLinked.delete(value);
+      this.#reverseMap.delete(value);
+      this.#map.delete(key);
+      return init && this.set(key, init(key));
+    }
+    if (this.#renewal) {
+      cache.timestamp = Date.now();
+    }
+    this.#addedLinked.add(value);
+    return value;
+  }
+  clear() {
+    this.#map.clear();
+    this.#reverseMap.clear();
+    this.#addedLinked.clear();
+  }
+};
+
+// src/cache.ts
+var LRUCache = class {
+  #bucket;
+  constructor(args) {
+    this.#bucket = new Cache({ max: 25, renewal: true, ...args });
+  }
+  #genKey(context, position) {
+    return [context.fileName, position?.line, position?.character, context.text].join(";");
+  }
+  get(context, position, init) {
+    return this.#bucket.get(this.#genKey(context, position), init);
+  }
+  clear() {
+    this.#bucket.clear?.();
+  }
+};
+
+// src/data-provider.ts
+var import_vscode_html_languageservice = require("@mantou/vscode-html-languageservice");
+
+// src/utils.ts
+function isCustomElementTag(tag) {
+  return tag.includes("-");
+}
+function isDepElement(node) {
+  const { fileName } = node.getSourceFile();
+  return ["/node_modules/", "/dist/", ".d.ts"].some((s) => fileName.includes(s));
+}
+function bindMemberFunction(o, keys2 = Object.keys(o)) {
+  return Object.fromEntries(keys2.map((key) => [key, o[key].bind?.(o)]));
+}
+function forEachNode(roots, fn) {
+  const list = [...roots];
+  while (true) {
+    const currentNode = list.pop();
+    if (!currentNode) return;
+    fn(currentNode);
+    list.push(..."getChildren" in currentNode ? currentNode.getChildren() : currentNode.children);
+  }
+}
+function hasDecorator(typescript, node, decorates) {
+  return node.modifiers?.some(
+    (modifier) => typescript.isDecorator(modifier) && typescript.isIdentifier(modifier.expression) && (!decorates || decorates.includes(modifier.expression.text))
+  );
+}
+function hasCallDecorator(typescript, node, decorates) {
+  return node.modifiers?.some(
+    (modifier) => typescript.isDecorator(modifier) && typescript.isCallExpression(modifier.expression) && (!decorates || decorates.includes(modifier.expression.expression.getText()))
+  );
+}
+function getTemplateNode(typescript, node) {
+  if (typescript.isTaggedTemplateExpression(node)) return node.template;
+  if (typescript.isTemplateExpression(node)) return node;
+  if (typescript.isNoSubstitutionTemplateLiteral(node)) return node;
+}
+function isClassMapKey(typescript, node) {
+  if (!node.parent?.parent?.parent) return false;
+  const assignment = node.parent;
+  const obj = assignment.parent;
+  const callExp = obj.parent;
+  const key = typescript.isStringLiteral(node) || typescript.isIdentifier(node);
+  return key && (typescript.isPropertyAssignment(assignment) && assignment.initializer !== node || typescript.isShorthandPropertyAssignment(assignment)) && typescript.isObjectLiteralExpression(obj) && typescript.isCallExpression(callExp) && typescript.isIdentifier(callExp.expression) && callExp.expression.text === Utils.ClassMap;
+}
+function getAllStyleNode(typescript, typeChecker, node) {
+  const getArgNode = (arg) => {
+    if (typescript.isIdentifier(arg)) {
+      const decl = typeChecker.getSymbolAtLocation(arg)?.valueDeclaration;
+      if (!decl || !typescript.isVariableDeclaration(decl) || !decl.initializer) return;
+      return getArgNode(decl.initializer);
+    }
+    const styleNode = getTemplateNode(typescript, arg);
+    if (styleNode) return styleNode;
+    const argArg = typescript.isCallExpression(arg) && arg.arguments.at(0);
+    if (argArg && typescript.isObjectLiteralExpression(argArg)) {
+      return argArg.properties.map((p) => {
+        const initializer = typescript.isPropertyAssignment(p) && p.initializer;
+        return initializer ? getTemplateNode(typescript, initializer) : void 0;
+      });
+    }
+  };
+  return (node.modifiers || []).flatMap((m) => {
+    const arg = typescript.isDecorator(m) && typescript.isCallExpression(m.expression) && typescript.isIdentifier(m.expression.expression) && m.expression.expression.escapedText === Decorators.AdoptedStyle ? m.expression.arguments.at(0) : void 0;
+    if (!arg) return null;
+    return getArgNode(arg);
+  }).filter(isNotNullish);
+}
+function getTagFromNodeWithDecorator(typescript, node) {
+  if (!typescript.isClassDeclaration(node)) return;
+  for (const modifier of node.modifiers || []) {
+    if (typescript.isDecorator(modifier) && typescript.isCallExpression(modifier.expression) && modifier.expression.expression.getText() === Decorators.CustomElement) {
+      const arg = modifier.expression.arguments.at(0);
+      if (arg && typescript.isStringLiteral(arg)) {
+        return arg.text;
+      }
+    }
+  }
+}
+function getCurrentElementDecl(typescript, node) {
+  while (!getTagFromNodeWithDecorator(typescript, node)) {
+    node = node.parent;
+    if (!node) return;
+  }
+  return node;
+}
+function getAstNodeAtPosition(typescript, node, pos) {
+  if (node.pos > pos || node.end <= pos) return;
+  while (node.kind >= typescript.SyntaxKind.FirstNode) {
+    const nested = typescript.forEachChild(node, (child) => child.pos < pos && child.end >= pos ? child : void 0);
+    if (nested === void 0) break;
+    node = nested;
+  }
+  return node;
+}
+function getAllIdent(text) {
+  return [...text.matchAll(/[a-zA-Z0-9-_]+/g)].map(({ 0: v, index }) => ({
+    start: index,
+    length: v.length,
+    value: v
+  }));
+}
+function getIdentAtPosition(text, offset) {
+  for (const { value, start } of getAllIdent(text)) {
+    if (offset >= start && offset <= start + value.length) {
+      return { text: value, start, length: value.length };
+    }
+  }
+}
+function getAttrName(text) {
+  const attr = text.split("=").at(0);
+  const isNotLetter = hasDecoratorAttr(attr);
+  const offset = isNotLetter ? 1 : 0;
+  return {
+    attr: attr.slice(offset),
+    offset,
+    decorate: isNotLetter ? attr.at(0) : ""
+  };
+}
+function hasDecoratorAttr(str) {
+  return str.charCodeAt(0) < 65;
+}
+function getTagInfo(node, offset) {
+  const tag = node.tag;
+  const openStart = node.start + 1 + offset;
+  return {
+    node,
+    tag,
+    offset,
+    open: { start: openStart, length: tag.length },
+    end: node.endTagStart && {
+      start: node.endTagStart + 2 + offset,
+      length: node.end - node.endTagStart - 3
+    }
+  };
+}
+var marker = Symbol();
+function decorate(origin, cb) {
+  if (origin[marker]) return origin;
+  const result = cb(origin);
+  result[marker] = true;
+  return result;
+}
+
+// src/data-provider.ts
+var dataProvider = (0, import_vscode_html_languageservice.getDefaultHTMLDataProvider)();
+var HTMLDataProvider = class {
+  #ts;
+  #ctx;
+  constructor(ctx) {
+    this.#ts = ctx.ts;
+    this.#ctx = ctx;
+  }
+  getId() {
+    return NAME;
+  }
+  isApplicable() {
+    return true;
+  }
+  provideTags() {
+    return [...this.#ctx.elements].map(([tag, node]) => ({
+      name: tag,
+      attributes: [],
+      description: getDocComment(this.#ts, node)
+    }));
+  }
+  provideAttributes(tag) {
+    const ts = this.#ts;
+    const typeChecker = this.#ctx.getProgram().getTypeChecker();
+    const node = this.#ctx.elements.get(tag);
+    const result = [
+      { name: "v-if", description: "Similar to vue `v-if`" },
+      { name: "v-else-if", description: "Similar to vue `v-else-if`" },
+      { name: "v-else", description: "Similar to vue `v-else`", valueSet: "v" }
+    ];
+    const builtInAttrsAndEvents = dataProvider.provideAttributes("div").map((e) => ({ ...e, name: e.name.replace(/^on/, "@") }));
+    if (!node) return [...result, ...builtInAttrsAndEvents];
+    const isDep = isDepElement(node);
+    const props = typeChecker.getTypeAtLocation(node).getApparentProperties();
+    props.forEach((e) => {
+      const declaration = e.getDeclarations()?.at(0);
+      const prop = declaration && ts.isPropertyDeclaration(declaration);
+      if (!prop) return;
+      const hasPropDecorator = hasDecorator(ts, declaration);
+      if (!hasPropDecorator && !isDep) return;
+      const type = declaration.type && typeChecker.getTypeFromTypeNode(declaration.type);
+      const typeText = declaration.type?.getText();
+      const description = getDocComment(ts, declaration);
+      switch (type) {
+        // 一般是 attribute
+        case typeChecker.getStringType():
+        case typeChecker.getNumberType():
+          result.push({ name: e.name, description });
+          break;
+        // 一般是 boolean attribute
+        case typeChecker.getBooleanType():
+          result.push({ name: e.name, description, valueSet: "v" });
+          result.push({ name: `?${e.name}`, description });
+          break;
+        default: {
+          if (type && getUnionValues(type)) {
+            result.push({ name: e.name, description });
+          }
+        }
+      }
+      if (typeText?.startsWith(Types.Emitter)) {
+        result.push({ name: `@${camelToKebabCase(e.name)}`, description });
+      } else {
+        result.push({ name: `.${e.name}`, description });
+      }
+    });
+    result.push(...builtInAttrsAndEvents.filter((e) => e.name.startsWith("@")));
+    return result;
+  }
+  provideValues(tag, attr) {
+    const result = [];
+    const typeChecker = this.#ctx.getProgram().getTypeChecker();
+    const node = this.#ctx.elements.get(tag);
+    const prop = node && typeChecker.getTypeAtLocation(node).getProperty(getAttrName(attr).attr);
+    const values = prop && getUnionValues(typeChecker.getTypeOfSymbol(prop));
+    values?.forEach((name) => result.push({ name }));
+    if (attr === "class" || attr === "id") {
+      const currentElementDecl = getCurrentElementDecl(this.#ts, this.#ctx.currentNode);
+      if (currentElementDecl) {
+        this.#ctx.getAllCss(currentElementDecl).forEach(({ classIdNodeMap }) => {
+          classIdNodeMap.entries().filter(([key]) => !(+(attr === "id") ^ +key.startsWith("#"))).forEach(([classOrId]) => {
+            result.push({ name: classOrId.slice(attr === "id" ? 1 : 0) });
+          });
+        });
+      }
+    }
+    return result;
+  }
+};
+function getUnionValues(type) {
+  if (!type.isUnion()) return;
+  const result = [];
+  type.types.forEach((e) => {
+    if (!e.isLiteral()) return;
+    result.push(String(e.value));
+  });
+  return result;
+}
+var COMMENT_LINE_CONTENT = /^(\/?[ *\t]*)?(?<str>.*?)(\**\/)?$/gm;
+function getDocComment(typescript, declaration) {
+  const fullText = declaration.getSourceFile().getFullText();
+  const commentRanges = typescript.getLeadingCommentRanges(fullText, declaration.getFullStart());
+  const commentStrings = commentRanges?.filter(({ kind }) => kind === typescript.SyntaxKind.MultiLineCommentTrivia).map(({ pos, end }) => {
+    const fullComment = [...fullText.slice(pos, end).matchAll(COMMENT_LINE_CONTENT)];
+    return fullComment.map((m) => m.groups.str).join("\n");
+  });
+  return commentStrings?.join("\n\n");
+}
+
+// src/context.ts
+var NodeMap = class {
+  #map = {};
+  get(key) {
+    return this.#map[key];
+  }
+  add(key, value) {
+    if (!this.#map[key]) this.#map[key] = [];
+    this.#map[key].push(value);
+  }
+  entries() {
+    return Object.entries(this.#map);
+  }
+};
+var Context = class {
+  // 用于 data-provider 自动完成
+  currentNode;
+  // TODO: 支持同名元素，查找时使用最近的声明
+  elements;
+  builtInElements;
+  ts;
+  config;
+  project;
+  logger;
+  cssLanguageService;
+  htmlLanguageService;
+  htmlSourceHelper;
+  cssSourceHelper;
+  htmlTemplateStringSettings;
+  cssTemplateStringSettings;
+  getProgram;
+  constructor(typescript, config, info, logger) {
+    this.ts = typescript;
+    this.config = config;
+    this.getProgram = () => info.languageService.getProgram();
+    this.project = info.project;
+    this.logger = logger;
+    this.elements = new StringWeakMap();
+    this.builtInElements = new StringWeakMap();
+    this.cssLanguageService = (0, import_vscode_css_languageservice.getCSSLanguageService)({});
+    this.htmlLanguageService = (0, import_vscode_html_languageservice2.getLanguageService)({
+      customDataProviders: [new HTMLDataProvider(this)]
+    });
+    this.htmlTemplateStringSettings = {
+      tags: ["html", "raw", "h"],
+      enableForStringWithSubstitutions: true,
+      getSubstitution
+    };
+    this.cssTemplateStringSettings = {
+      tags: ["styled", "css"],
+      enableForStringWithSubstitutions: true,
+      getSubstitution,
+      isValidTemplate: (node) => isValidCSSTemplate(typescript, node, "css")
+    };
+    this.htmlSourceHelper = new import_standard_template_source_helper.default(
+      typescript,
+      this.htmlTemplateStringSettings,
+      new import_standard_script_source_helper.default(typescript, info.project),
+      logger
+    );
+    this.cssSourceHelper = new import_standard_template_source_helper.default(
+      typescript,
+      this.cssTemplateStringSettings,
+      new import_standard_script_source_helper.default(typescript, info.project),
+      logger
+    );
+  }
+  #virtualCssCache = new LRUCache({ max: 1e3 });
+  getCssDoc(text) {
+    return this.#virtualCssCache.get({ text, fileName: "" }, void 0, () => {
+      const vDoc = createVirtualDocument("css", text);
+      const vCss = this.cssLanguageService.parseStylesheet(vDoc);
+      const tagNodeMap = new NodeMap();
+      const classIdNodeMap = new NodeMap();
+      const propNodeMap = new NodeMap();
+      forEachNode(vCss.getChildren(), (node) => {
+        if (node.type === import_vscode_css_languageservice.NodeType.ElementNameSelector) {
+          tagNodeMap.add(node.getText(), node);
+        }
+        if (node.type === import_vscode_css_languageservice.NodeType.IdentifierSelector || node.parent?.type === import_vscode_css_languageservice.NodeType.ClassSelector) {
+          classIdNodeMap.add(node.getText(), node);
+        }
+        if (node.parent?.type === import_vscode_css_languageservice.NodeType.CustomPropertyDeclaration) {
+          propNodeMap.add(node.getText(), node);
+        }
+      });
+      return { vDoc, vCss, tagNodeMap, classIdNodeMap, customPropNodeMap: propNodeMap };
+    });
+  }
+  getAllCss(node) {
+    return getAllStyleNode(this.ts, this.getProgram().getTypeChecker(), node).map((templateNode) => {
+      const { fileName } = templateNode.getSourceFile();
+      const templateContext = this.cssSourceHelper.getTemplate(fileName, templateNode.pos + 1);
+      if (!templateContext) return;
+      return { ...this.getCssDoc(templateContext.text), templateContext, templateNode };
+    }).filter(isNotNullish);
+  }
+  #virtualHtmlCache = new LRUCache({ max: 1e3 });
+  getHtmlDoc(text) {
+    return this.#virtualHtmlCache.get({ text, fileName: "" }, void 0, () => {
+      const vDoc = createVirtualDocument("html", text);
+      const vHtml = this.htmlLanguageService.parseHTMLDocument(vDoc);
+      const tagNodeMap = new NodeMap();
+      const classIdNodeMap = new NodeMap();
+      vHtml.roots.forEach(function process(e, index, arr) {
+        e.prev = arr[index - 1];
+        e.next = arr[index + 1];
+        e.tag && tagNodeMap.add(e.tag, e);
+        const idAttr = e.attributesMap.get("id");
+        const classAttr = e.attributesMap.get("class");
+        if (idAttr?.value) {
+          const text2 = getIdentAtPosition(idAttr.value, 1);
+          if (text2) {
+            classIdNodeMap.add(`#${text2.text}`, {
+              start: idAttr.end + 1 + text2.start,
+              length: text2.length
+            });
+          }
+        }
+        if (classAttr?.value) {
+          getAllIdent(classAttr.value).forEach((text2) => {
+            classIdNodeMap.add(text2.value, {
+              start: classAttr.end + 1 + text2.start,
+              length: text2.length
+            });
+          });
+        }
+        e.children.forEach(process);
+      });
+      return { vDoc, vHtml, tagNodeMap, classIdNodeMap };
+    });
+  }
+  prepareComplete(node) {
+    const tags = [...this.elements].map(([tag]) => tag);
+    (0, import_vscode_emmet_helper.updateTags)(tags);
+    (0, import_vscode_css_languageservice.updateTags)(tags);
+    this.currentNode = node;
+  }
+  getTagFromNode(node, supportClassName = isDepElement(node)) {
+    if (!this.ts.isClassDeclaration(node)) return;
+    const tag = getTagFromNodeWithDecorator(this.ts, node);
+    if (tag) return tag;
+    if (supportClassName && node.name && this.ts.isIdentifier(node.name)) {
+      return this.config.elementDefineRules.findTag(node.name.text);
+    }
+  }
+  updateElement(file) {
+    for (const [tag, decl] of this.elements) {
+      if (decl.getSourceFile().fileName === file.fileName) {
+        this.elements.delete?.(tag);
+      }
+    }
+    const isDep = isDepElement(file);
+    this.ts.forEachChild(file, (node) => {
+      const tag = this.getTagFromNode(node, isDep);
+      if (tag && this.ts.isClassDeclaration(node)) {
+        this.elements.set(tag, node);
+      }
+    });
+  }
+  #initElementsCache = /* @__PURE__ */ new WeakSet();
+  /**
+   * 当 project 准备好了执行
+   */
+  initElements() {
+    const program = this.getProgram();
+    if (this.#initElementsCache.has(this.project)) return;
+    this.#initElementsCache.add(this.project);
+    const files = program.getSourceFiles();
+    files.forEach((file) => this.updateElement(file));
+    const typeChecker = program.getTypeChecker();
+    const symbols = typeChecker.getSymbolsInScope(files.at(0), this.ts.SymbolFlags.Interface);
+    symbols.forEach((symbol) => {
+      const name = symbol.escapedName.toString();
+      const match = name.match(/^(SVG|HTML)(\w*)Element$/);
+      const declaration = symbol.declarations?.find((e) => this.ts.isInterfaceDeclaration(e));
+      if (!match || !declaration) return;
+      if (name in partialBuiltInElementMap) {
+        partialBuiltInElementMap[name].forEach((e) => this.builtInElements.set(e, declaration));
+      } else {
+        this.builtInElements.set(match[2].toLowerCase(), declaration);
+      }
+    });
+  }
+};
+var partialBuiltInElementMap = {
+  HTMLElement: [
+    "abbr",
+    "address",
+    "article",
+    "aside",
+    "b",
+    "bid",
+    "bdo",
+    "cite",
+    "code",
+    "dd",
+    "dfn",
+    "dt",
+    "em",
+    "figcaption",
+    "figure",
+    "footer",
+    "header",
+    "hgroup",
+    "i",
+    "kbd",
+    "main",
+    "mark",
+    "nav",
+    "noscript",
+    "rp",
+    "rt",
+    "ruby",
+    "s",
+    "samp",
+    "search",
+    "section",
+    "small",
+    "strong",
+    "sub",
+    "summary",
+    "sup",
+    "u",
+    "var",
+    "wbr"
+  ],
+  HTMLIFrameElement: ["iframe"],
+  HTMLFieldSetElement: ["fieldset"],
+  HTMLFencedFrameElement: ["fencedframe"],
+  HTMLSelectedContentElement: ["selectedcontent"],
+  HTMLParagraphElement: ["p"],
+  HTMLOptGroupElement: ["optgroup"],
+  HTMLTextAreaElement: ["textarea"],
+  HTMLDListElement: ["dl"],
+  HTMLOListElement: ["ol"],
+  HTMLUListElement: ["ul"],
+  HTMLHeadingElement: ["h1", "h2", "h3", "h4", "h5", "h6"],
+  HTMLModElement: ["del", "ins"],
+  HTMLQuoteElement: ["blockquote", "q", "cite"],
+  HTMLTableCaptionElement: ["caption"],
+  HTMLTableCellElement: ["th", "td"],
+  HTMLTableColElement: ["col"],
+  HTMLTableRowElement: ["tr"],
+  HTMLTableSectionElement: ["thead", "tfoot", "tbody"],
+  // 和 svg 同名元素使用 html 元素对待
+  SVGAElement: [],
+  HTMLAnchorElement: ["a"],
+  SVGImageElement: [],
+  HTMLImageElement: ["img"],
+  SVGStyleElement: [],
+  HTMLStyleElement: ["style"],
+  SVGScriptElement: [],
+  HTMLScriptElement: ["script"],
+  SVGTitleElement: [],
+  HTMLTitleElement: ["title"]
+};
+function createVirtualDocument(languageId, content) {
+  return import_vscode_html_languageservice2.TextDocument.create(`embedded://document.${languageId}`, languageId, 1, content);
+}
+function getSubstitution(templateString, start, end) {
+  return templateString.slice(start, end).replaceAll(/[^\n]/g, HTML_SUBSTITUTION_CHAR);
+}
+function isValidCSSTemplate(typescript, node, callName) {
+  switch (node.kind) {
+    case typescript.SyntaxKind.NoSubstitutionTemplateLiteral:
+    case typescript.SyntaxKind.TemplateExpression: {
+      const parent = node.parent;
+      if (typescript.isCallExpression(parent) && parent.expression.getText() === callName) {
+        return true;
+      }
+      if (typescript.isPropertyAssignment(parent)) {
+        const call = parent.parent.parent;
+        if (typescript.isCallExpression(call) && call.expression.getText() === callName) {
+          return true;
+        }
+      }
+      return false;
+    }
+    default:
+      return false;
+  }
+}
+
+// src/decorate-css.ts
+var import_vscode_css_languageservice2 = require("@mantou/vscode-css-languageservice");
+var import_vscode_emmet_helper2 = require("@mantou/vscode-emmet-helper");
+
+// src/translates.ts
+var vscode = __toESM(require("vscode-languageserver-types"));
+function translateCompletionItemsToCompletionInfo(context, items) {
+  return {
+    defaultCommitCharacters: [],
+    isGlobalCompletion: false,
+    isMemberCompletion: false,
+    isNewIdentifierLocation: false,
+    entries: items.items.map((x) => translateCompletionEntry(context, x))
+  };
+}
+function translateCompletionEntry(context, vsItem) {
+  const entry = {
+    name: vsItem.label,
+    kind: translationCompletionItemKind(context, vsItem.kind),
+    sortText: "0",
+    filterText: vsItem.label,
+    labelDetails: { description: vsItem.detail }
+  };
+  if (vsItem.textEdit) {
+    entry.isSnippet = vsItem.insertTextFormat === vscode.InsertTextFormat.Snippet || void 0;
+    entry.insertText = vsItem.textEdit.newText;
+    entry.replacementSpan = "range" in vsItem.textEdit ? toTsSpan(context, vsItem.textEdit.range) : void 0;
+  }
+  return entry;
+}
+function translationCompletionItemKind(context, kind) {
+  const typescript = context.typescript;
+  switch (kind) {
+    case vscode.CompletionItemKind.Method:
+      return typescript.ScriptElementKind.memberFunctionElement;
+    case vscode.CompletionItemKind.Function:
+      return typescript.ScriptElementKind.functionElement;
+    case vscode.CompletionItemKind.Constructor:
+      return typescript.ScriptElementKind.constructorImplementationElement;
+    case vscode.CompletionItemKind.Field:
+    case vscode.CompletionItemKind.Variable:
+      return typescript.ScriptElementKind.variableElement;
+    case vscode.CompletionItemKind.Class:
+      return typescript.ScriptElementKind.classElement;
+    case vscode.CompletionItemKind.Interface:
+      return typescript.ScriptElementKind.interfaceElement;
+    case vscode.CompletionItemKind.Module:
+      return typescript.ScriptElementKind.moduleElement;
+    case vscode.CompletionItemKind.Property:
+      return typescript.ScriptElementKind.memberVariableElement;
+    case vscode.CompletionItemKind.Unit:
+    case vscode.CompletionItemKind.Value:
+      return typescript.ScriptElementKind.constElement;
+    case vscode.CompletionItemKind.Enum:
+      return typescript.ScriptElementKind.enumElement;
+    case vscode.CompletionItemKind.Keyword:
+      return typescript.ScriptElementKind.keyword;
+    case vscode.CompletionItemKind.Color:
+      return typescript.ScriptElementKind.constElement;
+    case vscode.CompletionItemKind.Reference:
+      return typescript.ScriptElementKind.alias;
+    case vscode.CompletionItemKind.File:
+      return typescript.ScriptElementKind.moduleElement;
+    default:
+      return typescript.ScriptElementKind.unknown;
+  }
+}
+function toTsSpan(context, range) {
+  const editStart = context.toOffset(range.start);
+  const editEnd = context.toOffset(range.end);
+  return {
+    start: editStart,
+    length: editEnd - editStart
+  };
+}
+function translateHover(context, hover, position, offset = 0) {
+  const typescript = context.typescript;
+  const header = [];
+  const docs = [];
+  const convertPart = (hoverContents) => {
+    if (typeof hoverContents === "string") {
+      docs.push({ kind: "unknown", text: hoverContents });
+    } else if (Array.isArray(hoverContents)) {
+      hoverContents.forEach(convertPart);
+    } else if ("language" in hoverContents && hoverContents.language === "html") {
+      header.push({ kind: "unknown", text: hoverContents.value });
+    } else {
+      docs.push({ kind: "unknown", text: hoverContents.value });
+    }
+  };
+  convertPart(hover.contents);
+  const start = context.toOffset(hover.range ? hover.range.start : position);
+  return {
+    kind: typescript.ScriptElementKind.string,
+    kindModifiers: "",
+    textSpan: {
+      start: start - offset,
+      length: hover.range ? context.toOffset(hover.range.end) - start : 1
+    },
+    displayParts: header,
+    documentation: docs,
+    tags: []
+  };
+}
+function translateFoldingRangeKind(context, kind) {
+  const typescript = context.typescript;
+  switch (kind) {
+    case vscode.FoldingRangeKind.Comment:
+      return typescript.OutliningSpanKind.Comment;
+    case vscode.FoldingRangeKind.Imports:
+      return typescript.OutliningSpanKind.Imports;
+    case vscode.FoldingRangeKind.Region:
+      return typescript.OutliningSpanKind.Region;
+    default:
+      return typescript.OutliningSpanKind.Code;
+  }
+}
+function translateFoldingRange(context, range) {
+  const start = context.toOffset({ line: range.startLine, character: range.startCharacter || 0 });
+  const end = context.toOffset({ line: range.endLine, character: range.endCharacter || 0 });
+  return {
+    kind: translateFoldingRangeKind(context, range.kind),
+    autoCollapse: true,
+    bannerText: range.collapsedText || "",
+    textSpan: {
+      start,
+      length: end - start
+    },
+    hintSpan: {
+      start,
+      length: end - start
+    }
+  };
+}
+function translateCompletionItemsToCompletionEntryDetails(context, item) {
+  return {
+    name: item.label,
+    kindModifiers: "declare",
+    kind: item.kind ? translationCompletionItemKind(context, item.kind) : context.typescript.ScriptElementKind.unknown,
+    displayParts: toDisplayParts(item.detail),
+    documentation: toDisplayParts(item.documentation, true),
+    tags: []
+  };
+}
+function genDefaultCompletionEntryDetails(context, name) {
+  return {
+    name,
+    kindModifiers: "",
+    kind: context.typescript.ScriptElementKind.unknown,
+    displayParts: toDisplayParts(name),
+    documentation: [],
+    tags: []
+  };
+}
+function toDisplayParts(text, isDoc = false) {
+  if (!text) return [];
+  const escapeText = (unsafe) => unsafe.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&#39;").replaceAll(" ", "&nbsp;").replaceAll("\n", "  \n").replaceAll("	", "&emsp;");
+  return [
+    {
+      kind: "unknown",
+      text: typeof text !== "string" ? text.value : isDoc ? escapeText(text) : text
+    }
+  ];
+}
+function genElementDefinitionInfo(context, { start, length }, definitionNode) {
+  const htmlOffset = context.node.pos + 1;
+  return {
+    textSpan: { start, length },
+    definitions: [
+      {
+        containerName: "Custom Element",
+        containerKind: context.typescript.ScriptElementKind.unknown,
+        kind: context.typescript.ScriptElementKind.classElement,
+        name: definitionNode.name.text,
+        fileName: definitionNode.getSourceFile().fileName,
+        textSpan: {
+          start: definitionNode.name.getStart() - htmlOffset,
+          length: definitionNode.name.text.length
+        }
+      }
+    ]
+  };
+}
+function genAttrDefinitionInfo(context, { start, length }, propDeclaration) {
+  const htmlOffset = context.node.pos + 1;
+  const propName = propDeclaration.getText();
+  return {
+    textSpan: { start, length },
+    definitions: [
+      {
+        containerName: "Attribute",
+        containerKind: context.typescript.ScriptElementKind.unknown,
+        kind: context.typescript.ScriptElementKind.memberVariableElement,
+        name: propName,
+        fileName: propDeclaration.getSourceFile().fileName,
+        textSpan: {
+          start: propDeclaration.getStart() - htmlOffset,
+          length: propName.length
+        }
+      }
+    ]
+  };
+}
+function genCurrentCtxDefinitionInfo(context, { start, length }, definitionTextSpan) {
+  return {
+    textSpan: { start, length },
+    definitions: [
+      {
+        containerName: "Attribute",
+        containerKind: context.typescript.ScriptElementKind.unknown,
+        kind: context.typescript.ScriptElementKind.memberVariableElement,
+        name: context.text.slice(start, start + length),
+        fileName: context.fileName,
+        textSpan: definitionTextSpan
+      }
+    ]
+  };
+}
+function genCurrentCtxCssDefinitionInfo(context, value, start, definitions) {
+  const htmlOffset = context.node.getStart();
+  const length = value.length;
+  return {
+    textSpan: { start, length },
+    definitions: definitions.flatMap(
+      ({ ctx, nodes, offset = 0 }) => nodes.map((node) => ({
+        containerName: "AttributeValue",
+        containerKind: context.typescript.ScriptElementKind.unknown,
+        kind: context.typescript.ScriptElementKind.memberVariableElement,
+        name: value,
+        fileName: context.fileName,
+        textSpan: { start: node.offset + ctx.node.pos - offset - htmlOffset, length: node.length }
+      }))
+    )
+  };
+}
+
+// src/decorate-css.ts
+var CSSLanguageService = class {
+  #completionsCache = new LRUCache({ max: 1 });
+  #diagnosticsCache = new LRUCache();
+  #ctx;
+  constructor(ctx) {
+    this.#ctx = ctx;
+    onConfigurationUpdate(() => this.#diagnosticsCache.clear());
+  }
+  #normalize(context, position) {
+    const parent = context.node.parent;
+    const tag = context.typescript.isTaggedTemplateExpression(parent) && parent.tag.getText();
+    const isStyle = context.typescript.isPropertyAssignment(parent) || tag === "styled";
+    if (!isStyle) return { offset: 0, text: context.text, pos: { ...position } };
+    const appendBefore = ".parent { ";
+    const appendAfter = " }";
+    const character = position.line === 0 ? position.character + appendBefore.length : position.character;
+    return {
+      offset: appendBefore.length,
+      text: `${appendBefore}${context.text}${appendAfter}`,
+      pos: { line: position.line, character }
+    };
+  }
+  #getCompletionsAtPosition(context, position) {
+    return this.#completionsCache.get(context, position, () => {
+      const { text, pos } = this.#normalize(context, position);
+      const { vDoc, vCss } = this.#ctx.getCssDoc(text);
+      let emmetResults;
+      const onCssProperty = () => emmetResults = (0, import_vscode_emmet_helper2.doComplete)(vDoc, pos, "css", this.#ctx.config.emmet);
+      this.#ctx.cssLanguageService.setCompletionParticipants([{ onCssProperty }]);
+      this.#ctx.prepareComplete(context.node);
+      const completions = this.#ctx.cssLanguageService.doComplete(vDoc, pos, vCss);
+      completions.items.push(...emmetResults?.items || []);
+      return completions;
+    });
+  }
+  getCompletionsAtPosition(context, position) {
+    return translateCompletionItemsToCompletionInfo(context, this.#getCompletionsAtPosition(context, position));
+  }
+  getCompletionEntryDetails(context, position, name) {
+    const completions = this.#getCompletionsAtPosition(context, position);
+    const item = completions.items.find((e) => e.label === name);
+    if (!item) return genDefaultCompletionEntryDetails(context, name);
+    return translateCompletionItemsToCompletionEntryDetails(context, item);
+  }
+  getQuickInfoAtPosition(context, position) {
+    const { text, pos } = this.#normalize(context, position);
+    const { vDoc, vCss } = this.#ctx.getCssDoc(text);
+    const hover = this.#ctx.cssLanguageService.doHover(vDoc, pos, vCss, {
+      documentation: true,
+      references: true
+    });
+    if (!hover) return;
+    return translateHover(context, hover, position, pos.character - position.character);
+  }
+  #getSyntacticDiagnostics(context) {
+    const { text, offset } = this.#normalize(context, { line: 0, character: 0 });
+    const { vDoc, vCss } = this.#ctx.getCssDoc(text);
+    const result = [];
+    const oDiagnostics = this.#ctx.cssLanguageService.doValidation(vDoc, vCss);
+    const file = this.#ctx.getProgram().getSourceFile(context.fileName);
+    const baseDiagnostic = { code: 0, file, source: NAME, category: context.typescript.DiagnosticCategory.Warning };
+    if (this.#ctx.config.strict) {
+      const scopeSelectors = /* @__PURE__ */ new Set([":host", ":scope", "&"]);
+      vCss.getChildren().forEach((rule) => {
+        if (rule.type !== import_vscode_css_languageservice2.NodeType.Ruleset) return;
+        const [selectors, declarations] = rule.getChildren();
+        const isScopeSelector = selectors?.getChildren().every((s) => scopeSelectors.has(s.getText()));
+        if (!isScopeSelector) return;
+        declarations.getChildren().forEach((decl) => {
+          const [property] = decl.getChildren();
+          if (property?.getText() === "display") {
+            result.push({
+              ...baseDiagnostic,
+              start: property.offset,
+              length: property.length,
+              messageText: `Do not set 'display' directly in '${selectors.getText()}', which will cause the 'hidden' attribute to be unavailable`
+            });
+          }
+        });
+      });
+    }
+    oDiagnostics.forEach(({ message, range }) => {
+      const start = context.toOffset(range.start);
+      result.push({
+        ...baseDiagnostic,
+        start: range.start.line === 0 ? start - offset : start,
+        length: context.toOffset(range.end) - start,
+        messageText: message
+      });
+    });
+    return result;
+  }
+  getSyntacticDiagnostics(context) {
+    this.#ctx.initElements();
+    return this.#diagnosticsCache.get(context, void 0, () => this.#getSyntacticDiagnostics(context));
+  }
+  getReferencesAtPosition(context, position) {
+    const typeChecker = this.#ctx.getProgram().getTypeChecker();
+    const { text, offset } = this.#normalize(context, position);
+    const { vCss } = this.#ctx.getCssDoc(text);
+    const node = vCss.findChildAtOffset(context.toOffset(position) + offset, true);
+    const result = [];
+    if (node?.type === import_vscode_css_languageservice2.NodeType.IdentifierSelector || node?.parent?.type === import_vscode_css_languageservice2.NodeType.ClassSelector) {
+      const classOrId = node.getText();
+      for (const [, decl] of this.#ctx.elements) {
+        const { fileName } = decl.getSourceFile();
+        const styles = getAllStyleNode(context.typescript, typeChecker, decl);
+        if (!styles.includes(context.node)) continue;
+        forEachNode(decl.getChildren(), (node2) => {
+          const templateNode = getTemplateNode(context.typescript, node2);
+          if (templateNode) {
+            const templateContext = this.#ctx.htmlSourceHelper.getTemplate(fileName, templateNode.pos + 1);
+            if (!templateContext) return;
+            const { classIdNodeMap } = this.#ctx.getHtmlDoc(templateContext.text);
+            classIdNodeMap.get(classOrId)?.forEach((n) => {
+              result.push({
+                fileName,
+                textSpan: { start: n.start + templateNode.pos - context.node.pos, length: n.length },
+                isWriteAccess: true
+              });
+            });
+          } else if (isClassMapKey(context.typescript, node2) && node2.text === classOrId) {
+            const isString = context.typescript.isStringLiteral(node2);
+            result.push({
+              fileName,
+              textSpan: {
+                start: node2.getStart() - context.node.pos - 1 + (isString ? 1 : 0),
+                length: node2.text.length
+              },
+              isWriteAccess: true
+            });
+          }
+        });
+      }
+    }
+    if (node?.parent?.type === import_vscode_css_languageservice2.NodeType.Property) {
+      forEachIdent(vCss, node.getText(), (cssNode) => {
+        result.push({
+          fileName: context.fileName,
+          textSpan: { start: cssNode.offset - offset, length: cssNode.end - cssNode.offset },
+          isWriteAccess: true
+        });
+      });
+    }
+    return result;
+  }
+  getDefinitionAndBoundSpan(context, position) {
+    const { text, offset } = this.#normalize(context, position);
+    const { vCss, customPropNodeMap } = this.#ctx.getCssDoc(text);
+    const empty = { textSpan: { start: 0, length: 0 } };
+    const node = vCss.findChildAtOffset(context.toOffset(position) + offset, true);
+    if (!node) return empty;
+    const textSpan = { start: node.offset - offset, length: node.length };
+    if (node.type === import_vscode_css_languageservice2.NodeType.IdentifierSelector || node.parent?.type === import_vscode_css_languageservice2.NodeType.ClassSelector || node.parent?.parent?.type === import_vscode_css_languageservice2.NodeType.CustomPropertyDeclaration) {
+      return genCurrentCtxDefinitionInfo(context, textSpan, textSpan);
+    }
+    const propDefinitions = customPropNodeMap.get(node.getText());
+    if (node.type === import_vscode_css_languageservice2.NodeType.Identifier && propDefinitions) {
+      return genCurrentCtxCssDefinitionInfo(context, node.getText(), node.offset - offset, [
+        { ctx: context, nodes: propDefinitions, offset }
+      ]);
+    }
+    if (node.parent?.type !== import_vscode_css_languageservice2.NodeType.ElementNameSelector) return empty;
+    const definitionNode = this.#ctx.elements.get(node.getText());
+    if (!definitionNode) return empty;
+    return genElementDefinitionInfo(context, textSpan, definitionNode);
+  }
+  // 不知道如何起作用的，没有被调用，但不加就没有 css 折叠了
+  getOutliningSpans(context) {
+    const { vDoc } = this.#ctx.getHtmlDoc(context.text);
+    const ranges = this.#ctx.cssLanguageService.getFoldingRanges(vDoc);
+    return ranges.map((range) => translateFoldingRange(context, range));
+  }
+};
+function forEachIdent(vCss, customPropName, fn) {
+  forEachNode(vCss.getChildren(), (ident) => {
+    if (ident.type !== import_vscode_css_languageservice2.NodeType.Identifier || ident.getText() !== customPropName) return;
+    if (ident.parent?.type !== import_vscode_css_languageservice2.NodeType.Term && ident?.parent?.type !== import_vscode_css_languageservice2.NodeType.Property) return;
+    fn(ident);
+  });
+}
+
+// src/decorate-html.ts
+var import_vscode_css_languageservice3 = require("@mantou/vscode-css-languageservice");
+var import_vscode_emmet_helper3 = require("@mantou/vscode-emmet-helper");
+var HTMLLanguageService = class {
+  #completionsCache = new LRUCache({ max: 1 });
+  #diagnosticsCache = new LRUCache();
+  #ctx;
+  constructor(ctx) {
+    this.#ctx = ctx;
+  }
+  #getAllStyleSheet(doc) {
+    const styles = [];
+    const nodes = [...doc.roots];
+    while (true) {
+      const node = nodes.pop();
+      if (!node) break;
+      if (node.tag === "style") styles.push(node);
+      nodes.push(...node.children);
+    }
+    return styles;
+  }
+  #getEmbeddedCss(context, position, doc) {
+    const node = doc.findNodeAt(context.toOffset(position));
+    if (node.tag !== "style") return;
+    const text = context.text.slice(node.startTagEnd, node.endTagStart);
+    const { vDoc, vCss } = this.#ctx.getCssDoc(text);
+    const offset = context.toOffset(position) - node.startTagEnd;
+    const toPosition = (pos) => context.toPosition(vDoc.offsetAt(pos) + node.startTagEnd);
+    return {
+      style: vCss,
+      vDoc,
+      position: vDoc.positionAt(offset),
+      updateRange: (range) => ({
+        start: toPosition(range.start),
+        end: toPosition(range.end)
+      })
+    };
+  }
+  #getCSSCompletionsAtPosition(context, position, doc) {
+    const css = this.#getEmbeddedCss(context, position, doc);
+    if (!css) return [];
+    let emmetResults;
+    const onCssProperty = () => emmetResults = (0, import_vscode_emmet_helper3.doComplete)(css.vDoc, css.position, "css", this.#ctx.config.emmet);
+    this.#ctx.cssLanguageService.setCompletionParticipants([{ onCssProperty }]);
+    (0, import_vscode_css_languageservice3.updateTags)([...this.#ctx.elements].map(([tag]) => tag));
+    const completions = this.#ctx.cssLanguageService.doComplete(css.vDoc, css.position, css.style);
+    completions.items.push(...emmetResults?.items || []);
+    return completions.items.map((e) => {
+      const textEdit = e.textEdit && "range" in e.textEdit && e.textEdit;
+      const newTextEdit = textEdit && { newText: textEdit.newText, range: css.updateRange(textEdit.range) };
+      return { ...e, textEdit: newTextEdit || e.textEdit };
+    });
+  }
+  #getCompletionsAtPosition(context, position) {
+    return this.#completionsCache.get(context, position, () => {
+      const { vDoc, vHtml } = this.#ctx.getHtmlDoc(context.text);
+      let emmetResults;
+      const onHtmlContent = () => emmetResults = (0, import_vscode_emmet_helper3.doComplete)(vDoc, position, "html", this.#ctx.config.emmet);
+      this.#ctx.htmlLanguageService.setCompletionParticipants([{ onHtmlContent }]);
+      this.#ctx.prepareComplete(context.node);
+      const completions = this.#ctx.htmlLanguageService.doComplete(vDoc, position, vHtml);
+      completions.items.push(...emmetResults?.items || []);
+      completions.items.push(...this.#getCSSCompletionsAtPosition(context, position, vHtml));
+      return completions;
+    });
+  }
+  getCompletionsAtPosition(context, position) {
+    return translateCompletionItemsToCompletionInfo(context, this.#getCompletionsAtPosition(context, position));
+  }
+  getCompletionEntryDetails(context, position, name) {
+    const completions = this.#getCompletionsAtPosition(context, position);
+    const item = completions.items.find((e) => e.label === name);
+    if (!item) return genDefaultCompletionEntryDetails(context, name);
+    return translateCompletionItemsToCompletionEntryDetails(context, item);
+  }
+  #getCSSQuickInfoAtPosition(context, position, doc) {
+    const css = this.#getEmbeddedCss(context, position, doc);
+    if (!css) return;
+    const hover = this.#ctx.cssLanguageService.doHover(css.vDoc, css.position, css.style, {
+      documentation: true,
+      references: true
+    });
+    if (!hover) return;
+    return { ...hover, range: hover.range && css.updateRange(hover.range) };
+  }
+  getQuickInfoAtPosition(context, position) {
+    const { vDoc, vHtml } = this.#ctx.getHtmlDoc(context.text);
+    const htmlHover = this.#ctx.htmlLanguageService.doHover(vDoc, position, vHtml, {
+      documentation: true,
+      references: true
+    });
+    const hover = htmlHover || this.#getCSSQuickInfoAtPosition(context, position, vHtml);
+    if (!hover) return;
+    return translateHover(context, hover, position);
+  }
+  #getCssSyntacticDiagnostics(context) {
+    return this.#diagnosticsCache.get(context, void 0, () => {
+      const { vHtml } = this.#ctx.getHtmlDoc(context.text);
+      const file = this.#ctx.getProgram().getSourceFile(context.fileName);
+      const styles = this.#getAllStyleSheet(vHtml);
+      const diagnostics = [];
+      styles.forEach((node) => {
+        const text = context.text.slice(node.startTagEnd, node.endTagStart);
+        const { vDoc, vCss } = this.#ctx.getCssDoc(text);
+        this.#ctx.cssLanguageService.doValidation(vDoc, vCss).forEach(({ message, range }) => {
+          const start = node.startTagEnd + vDoc.offsetAt(range.start);
+          const end = node.startTagEnd + vDoc.offsetAt(range.end);
+          diagnostics.push({
+            category: context.typescript.DiagnosticCategory.Warning,
+            code: 0,
+            file,
+            start,
+            length: end - start,
+            messageText: message,
+            source: NAME
+          });
+        });
+      });
+      return diagnostics;
+    });
+  }
+  #getHtmlSemanticDiagnostics(context) {
+    const offset = context.node.getStart() + 1;
+    const templateTag = context.node.parent.tag?.getText();
+    const { vHtml } = this.#ctx.getHtmlDoc(context.text);
+    const program = this.#ctx.getProgram();
+    const file = program.getSourceFile(context.fileName);
+    const typeChecker = program.getTypeChecker();
+    const diagnostics = [];
+    const baseDiagnostic = { file, source: NAME };
+    forEachNode(vHtml.roots, (node) => {
+      if (!node.tag) return;
+      const customElementTagDecl = this.#ctx.elements.get(node.tag);
+      const builtInElementTagDecl = this.#ctx.builtInElements.get(node.tag);
+      const baseTagDiagnostic = { ...baseDiagnostic, start: node.start + 1, length: node.tag.length };
+      if (this.#ctx.config.strict && templateTag !== "raw" && node.tag === "style") {
+        diagnostics.push({
+          ...baseTagDiagnostic,
+          category: context.typescript.DiagnosticCategory.Warning,
+          code: 106 /* NoStyleTag */,
+          messageText: `Use 'adoptedStyle' or 'createDecoratorTheme' instead of the style tag`
+        });
+      }
+      if (isCustomElementTag(node.tag) && !customElementTagDecl) {
+        diagnostics.push({
+          ...baseTagDiagnostic,
+          category: context.typescript.DiagnosticCategory.Warning,
+          code: 101 /* UnknownTag */,
+          messageText: `Unknown element tag '${node.tag}'`
+        });
+      }
+      const tagDeclaration = customElementTagDecl || builtInElementTagDecl;
+      if (!tagDeclaration) return;
+      const classType = typeChecker.getTypeAtLocation(tagDeclaration);
+      const isSVG = builtInElementTagDecl?.name.getText().startsWith("SVG");
+      if (tagDeclaration.name && isDeprecate(typeChecker.getSymbolAtLocation(tagDeclaration.name))) {
+        [node.start + 1, node.endTagStart && node.endTagStart + 2].filter(isNotNullish).forEach((tagStart) => {
+          diagnostics.push({
+            ...baseTagDiagnostic,
+            start: tagStart,
+            category: context.typescript.DiagnosticCategory.Suggestion,
+            code: 105 /* Deprecated */,
+            messageText: `Deprecated tag '${node.tag}'`,
+            reportsDeprecated: "true"
+          });
+        });
+      }
+      for (const [attributeName, { value, start, end }] of node.attributesMap) {
+        if (attributeName.startsWith(HTML_SUBSTITUTION_CHAR)) continue;
+        const hasValueSpan = value?.startsWith(HTML_SUBSTITUTION_CHAR);
+        const attrInfo = getAttrName(attributeName);
+        const propName = getPropName(attrInfo, !!builtInElementTagDecl);
+        const propType = getPropType(typeChecker, classType, propName, attrInfo.decorate === "@");
+        const attrBaseDiagnostic = { ...baseDiagnostic, start, length: end - start };
+        if (isDeprecate(classType.getProperty(propName))) {
+          diagnostics.push({
+            ...attrBaseDiagnostic,
+            category: context.typescript.DiagnosticCategory.Suggestion,
+            code: 105 /* Deprecated */,
+            messageText: `Deprecated prop '${attrInfo.attr}'`,
+            reportsDeprecated: "true"
+          });
+        }
+        const diagnostic = {
+          ...attrBaseDiagnostic,
+          category: context.typescript.DiagnosticCategory.Warning,
+          code: 103 /* PropTypeError */,
+          messageText: !propType ? `'${attributeName}' type error` : `'${attributeName}' not satisfied '${typeChecker.typeToString(propType)}'`
+        };
+        if (templateTag === "raw") {
+          if (attrInfo.decorate) {
+            diagnostics.push({
+              ...diagnostic,
+              code: 104 /* PropSyntaxError */,
+              messageText: `Raw HTML templates only support attributes`
+            });
+            continue;
+          }
+          if (hasValueSpan) {
+            diagnostics.push({
+              ...diagnostic,
+              code: 104 /* PropSyntaxError */,
+              messageText: `Please wrap the raw html template attribute value with "" to avoid parsing errors when the value is an empty string`
+            });
+            continue;
+          }
+        }
+        if ((attributeName === "v-else-if" || attributeName === "v-else") && !node.prev?.attributesMap.has("v-if") && !node.prev?.attributesMap.has("v-else-if")) {
+          diagnostics.push({
+            ...diagnostic,
+            code: 104 /* PropSyntaxError */,
+            messageText: `'${attrInfo.attr}' syntax error`
+          });
+          continue;
+        }
+        if (attributeName === "v-if" || attributeName === "v-else-if") {
+          const spanType = getSpanType(this.#ctx.ts, typeChecker, file, offset, end);
+          if (!hasValueSpan || !typeChecker.isTypeAssignableTo(spanType, typeChecker.getBooleanType())) {
+            diagnostics.push(diagnostic);
+          }
+          continue;
+        }
+        if (attributeName === "v-else") {
+          if (value !== null) {
+            diagnostics.push(diagnostic);
+          }
+          continue;
+        }
+        if (
+          // SVG 大小写敏感
+          !isSVG && attrInfo.decorate === "" && attributeName !== camelToKebabCase(attrInfo.attr)
+        ) {
+          diagnostics.push({
+            ...diagnostic,
+            code: 2552 /* AttrFormatError */,
+            messageText: `Consider using '${customElementTagDecl ? camelToKebabCase(attrInfo.attr) : attrInfo.attr.toLowerCase()}'`
+          });
+          continue;
+        }
+        if (!propType) {
+          if (
+            // SVG 元素有很多 css 属性，所以不检查
+            !isSVG && attrInfo.decorate !== "@"
+          ) {
+            diagnostics.push({
+              ...diagnostic,
+              code: 102 /* UnknownProp */,
+              messageText: `Unknown property '${attrInfo.attr}'`
+            });
+          }
+          continue;
+        }
+        if (globalEnumeratedBooleanAttr.has(attrInfo.attr) && // <div ?draggable=${xx}>
+        (attrInfo.decorate === "?" || // <div draggable>
+        value === null)) {
+          diagnostics.push({
+            ...diagnostic,
+            code: 104 /* PropSyntaxError */,
+            messageText: `Consider using '${camelToKebabCase(attrInfo.attr)}', must has value`
+          });
+          continue;
+        }
+        if (value === null) {
+          if (attrInfo.decorate) {
+            diagnostics.push({
+              ...diagnostic,
+              code: 104 /* PropSyntaxError */,
+              messageText: `Consider using '${camelToKebabCase(attrInfo.attr)}'`
+            });
+          } else if (propType !== typeChecker.getBooleanType()) {
+            diagnostics.push(diagnostic);
+          }
+          continue;
+        }
+        if (hasValueSpan) {
+          const spanType = getSpanType(this.#ctx.ts, typeChecker, file, offset, end);
+          switch (attrInfo.decorate) {
+            case "?": {
+              const boolType = getUnionType(typeChecker, [
+                typeChecker.getBooleanType(),
+                typeChecker.getUndefinedType(),
+                typeChecker.getNullType()
+              ]);
+              if (!typeChecker.isTypeAssignableTo(spanType, boolType)) {
+                diagnostics.push(diagnostic);
+              }
+              continue;
+            }
+            case ".":
+            case "@":
+              if (!typeChecker.isTypeAssignableTo(spanType, propType)) {
+                diagnostics.push(diagnostic);
+              }
+              continue;
+            default: {
+              const nullablePropType = getUnionType(typeChecker, [
+                propType,
+                typeChecker.getNullType(),
+                typeChecker.getUndefinedType()
+              ]);
+              if (!typeChecker.isTypeAssignableTo(spanType, nullablePropType) && (!typeChecker.isTypeAssignableTo(propType, typeChecker.getStringType()) || !typeChecker.isTypeAssignableTo(spanType, typeChecker.getStringType()))) {
+                diagnostics.push(diagnostic);
+              }
+              continue;
+            }
+          }
+        } else {
+          const types = [typeChecker.getStringType(), typeChecker.getNumberType()];
+          const valueLetter = value.startsWith('"') ? value.slice(1, -1) : value;
+          types.push(typeChecker.getStringLiteralType(valueLetter));
+          const numberValue = Number(valueLetter);
+          if (!Number.isNaN(numberValue)) {
+            types.push(typeChecker.getNumberLiteralType(numberValue));
+          }
+          if (attrInfo.decorate) {
+            diagnostics.push({
+              ...diagnostic,
+              code: 104 /* PropSyntaxError */,
+              messageText: `Consider using '${camelToKebabCase(attrInfo.attr)}'`
+            });
+          } else if (globalEnumeratedBooleanAttr.has(attrInfo.attr)) {
+            const values = ["true", "false", ...globalEnumeratedBooleanAttr.get(attrInfo.attr)];
+            if (!values.includes(valueLetter)) {
+              diagnostics.push({
+                ...diagnostic,
+                code: 103 /* PropTypeError */,
+                messageText: `Must be ${values.join(", ")}`
+              });
+            }
+          } else if (types.every((t) => !typeChecker.isTypeAssignableTo(t, propType))) {
+            diagnostics.push(diagnostic);
+          }
+        }
+      }
+    });
+    return diagnostics;
+  }
+  getSyntacticDiagnostics(context) {
+    this.#ctx.initElements();
+    return this.#getCssSyntacticDiagnostics(context);
+  }
+  getSemanticDiagnostics(context) {
+    return this.#getHtmlSemanticDiagnostics(context);
+  }
+  getDefinitionAndBoundSpan(context, position) {
+    const typeChecker = this.#ctx.getProgram().getTypeChecker();
+    const currentOffset = context.toOffset(position);
+    const { vHtml } = this.#ctx.getHtmlDoc(context.text);
+    const { node, attrStart, attrEnd, attrName, attrValue } = getHTMLNodeAtPosition(vHtml, currentOffset);
+    const empty = { textSpan: { start: 0, length: 0 } };
+    const notInStartTag = currentOffset > node.startTagEnd;
+    const startTagNameStart = node.start + 1;
+    if (!node.tag) return empty;
+    if (node.tag === "style" && notInStartTag) {
+      const { style, vDoc, position: pos } = this.#getEmbeddedCss(context, position, vHtml);
+      const cssNode = style.findChildAtOffset(vDoc.offsetAt(pos), true);
+      if (!cssNode || cssNode.parent?.type !== import_vscode_css_languageservice3.NodeType.ElementNameSelector) return empty;
+      const definitionNode2 = this.#ctx.elements.get(cssNode.getText());
+      if (!definitionNode2) return empty;
+      return genElementDefinitionInfo(
+        context,
+        { start: cssNode.offset + node.startTagEnd, length: cssNode.length },
+        definitionNode2
+      );
+    }
+    const definitionNode = this.#ctx.elements.get(node.tag) || this.#ctx.builtInElements.get(node.tag);
+    if (!definitionNode || notInStartTag) return empty;
+    if (currentOffset < startTagNameStart + node.tag.length) {
+      return genElementDefinitionInfo(context, { start: startTagNameStart, length: node.tag.length }, definitionNode);
+    }
+    if (!attrName) return empty;
+    const { attr, offset } = getAttrName(attrName);
+    if (attr === "class" || attr === "id") {
+      if (!attrValue) return empty;
+      const currentAttrValue = getIdentAtPosition(attrValue, currentOffset - (attrEnd + 1));
+      const currentElementDecl = getCurrentElementDecl(context.typescript, context.node);
+      if (!currentAttrValue || !currentElementDecl) return empty;
+      return genCurrentCtxCssDefinitionInfo(
+        context,
+        currentAttrValue.text,
+        attrEnd + 1 + currentAttrValue.start,
+        this.#ctx.getAllCss(currentElementDecl).flatMap(({ classIdNodeMap, templateContext }) => {
+          const nodes = classIdNodeMap.get(attr === "id" ? `#${currentAttrValue.text}` : currentAttrValue.text);
+          return { ctx: templateContext, nodes: nodes || [], offset: 0 };
+        }).filter(isNotNullish)
+      );
+    }
+    if (currentOffset > attrEnd) return empty;
+    if (attr === "v-else" || attr === "v-else-if") {
+      const ifAttr = node.prev?.attributesMap.get("v-if") || node.prev?.attributesMap.get("v-else-if");
+      if (!ifAttr) return empty;
+      return genCurrentCtxDefinitionInfo(
+        context,
+        { start: attrStart + offset, length: attr.length },
+        { start: ifAttr.start, length: ifAttr.end - ifAttr.start }
+      );
+    }
+    const propSymbol = typeChecker.getTypeAtLocation(definitionNode).getProperty(kebabToCamelCase(attr));
+    const propDeclaration = propSymbol?.getDeclarations()?.at(0);
+    if (!propDeclaration) return empty;
+    return genAttrDefinitionInfo(context, { start: attrStart + offset, length: attr.length }, propDeclaration);
+  }
+  // 不知道如何起作用的，没有被调用，但不加就没有 HTML 折叠了
+  // 所以也忽略了 HTML 里面的内联样式折叠
+  getOutliningSpans(context) {
+    const { vDoc } = this.#ctx.getHtmlDoc(context.text);
+    const ranges = this.#ctx.htmlLanguageService.getFoldingRanges(vDoc);
+    return ranges.map((range) => translateFoldingRange(context, range));
+  }
+  getJsxClosingTagAtPosition(context, position) {
+    const currentOffset = context.toOffset(position);
+    const { vHtml } = this.#ctx.getHtmlDoc(context.text);
+    const node = vHtml.findNodeAt(currentOffset);
+    if (!node.tag || !node.startTagEnd || voidElementTags.has(node.tag)) return;
+    if (!node.endTagStart) return { newText: `</${node.tag}>` };
+  }
+  getDocumentHighlights(context, position) {
+    const { vDoc, vHtml } = this.#ctx.getHtmlDoc(context.text);
+    const docHighlights = this.#ctx.htmlLanguageService.findDocumentHighlights(vDoc, position, vHtml);
+    return [
+      {
+        fileName: context.fileName,
+        highlightSpans: docHighlights.map(({ range }) => {
+          const start = vDoc.offsetAt(range.start);
+          const end = vDoc.offsetAt(range.end);
+          return { textSpan: { start, length: end - start }, kind: this.#ctx.ts.HighlightSpanKind.definition };
+        })
+      }
+    ];
+  }
+  getCodeFixesAtPosition(context, start, end, errorCodes) {
+    const result = [];
+    if (errorCodes.includes(2552 /* AttrFormatError */)) {
+      const { vHtml } = this.#ctx.getHtmlDoc(context.text);
+      const node = vHtml.findNodeAt(start);
+      const isBuiltInTag = !!this.#ctx.builtInElements.get(node.tag);
+      const attr = context.text.slice(start, end);
+      const targetAttr = isBuiltInTag ? attr.toLowerCase() : camelToKebabCase(attr);
+      const textChanges = [{ span: { start, length: end - start }, newText: targetAttr }];
+      result.push({
+        fixName: context.fileName,
+        description: `Convert attribute to '${targetAttr}'`,
+        changes: [{ fileName: context.fileName, textChanges }]
+      });
+    }
+    return result;
+  }
+};
+var voidElementTags = /* @__PURE__ */ new Set([
+  "area",
+  "base",
+  "br",
+  "col",
+  "embed",
+  "hr",
+  "img",
+  "input",
+  "link",
+  "meta",
+  "param",
+  "source",
+  "track",
+  "wbr"
+]);
+function getSpanExpression(typescript, file, pos) {
+  let node = getAstNodeAtPosition(typescript, file, pos);
+  while (!typescript.isTemplateSpan(node)) {
+    node = node.parent;
+    if (!node) return;
+  }
+  return node.expression;
+}
+function getSpanType(typescript, typeChecker, file, htmlOffset, attrNameEnd) {
+  const valueOffset = attrNameEnd + htmlOffset + 4;
+  const spanExp = getSpanExpression(typescript, file, valueOffset);
+  return typeChecker.getTypeAtLocation(spanExp);
+}
+var buildInElementNoGlobalAttrPropMap = /* @__PURE__ */ new Map([
+  ["crossorigin", "crossOrigin"],
+  ["rowspan", "rowSpan"],
+  ["colspan", "colSpan"],
+  // <input> list: string
+  ["list", "ariaLabelledby"]
+]);
+var globalAttrPropMap = /* @__PURE__ */ new Map([["contenteditable", "contentEditable"]]);
+var globalEnumeratedBooleanAttr = /* @__PURE__ */ new Map([
+  ["draggable", []],
+  ["spellcheck", []],
+  ["contenteditable", ["plaintext-only"]]
+]);
+function getPropName(attrInfo, isNativeTag) {
+  if (attrInfo.attr.startsWith("data-")) {
+    return attrInfo.attr;
+  }
+  return globalAttrPropMap.get(attrInfo.attr) || (isNativeTag ? buildInElementNoGlobalAttrPropMap.get(attrInfo.attr) || kebabToCamelCase(attrInfo.attr) : kebabToCamelCase(attrInfo.attr));
+}
+function getPropType(typeChecker, classType, propName, isEvent) {
+  if (propName.startsWith("data-")) {
+    return typeChecker.getStringType();
+  }
+  switch (propName) {
+    case "class":
+    case "style":
+    case "part":
+    case "exportparts":
+    case "accesskey":
+    case "xmlns":
+    case "viewBox":
+    case "ariaLabelledby":
+      return typeChecker.getStringType();
+    case "tabindex":
+      return typeChecker.getNumberType();
+    case "ariaAtomic":
+    case "ariaBusy":
+    case "ariaChecked":
+    case "ariaDisabled":
+    case "ariaExpanded":
+    case "ariaGrabbed":
+    case "ariaHidden":
+    case "ariaModal":
+    case "ariaMultiline":
+    case "ariaMultiselectable":
+    case "ariaReadonly":
+    case "ariaRequired":
+    case "ariaPressed":
+    case "ariaSelected":
+      return getUnionType(typeChecker, [
+        typeChecker.getStringType(),
+        typeChecker.getBooleanType(),
+        typeChecker.getUndefinedType()
+      ]);
+    default: {
+      const propSymbol = classType.getProperty(propName);
+      const propType = propSymbol && typeChecker.getTypeOfSymbol(propSymbol);
+      if (!isEvent) return propType;
+      const eventHandleType = getEmitterHandleType(typeChecker, classType, propType);
+      return getUnionType(typeChecker, [eventHandleType, typeChecker.getUndefinedType()]);
+    }
+  }
+}
+function isDeprecate(symbol) {
+  if (!symbol) return false;
+  const tags = symbol.getJsDocTags();
+  return tags.some(({ name }) => name === "deprecated");
+}
+function getEmitterHandleType(typeChecker, classType, propType) {
+  const handleSymbol = propType?.getProperty("handler");
+  if (handleSymbol) return typeChecker.getTypeOfSymbol(handleSymbol);
+  const addEventListenerSymbol = classType.getProperty("addEventListener");
+  if (!addEventListenerSymbol) return typeChecker.getAnyType();
+  const addEventListenerDecls = addEventListenerSymbol.declarations;
+  const addEventListenerDecl = addEventListenerDecls.find((e) => !e.typeParameters);
+  const listenerDecl = addEventListenerDecl.parameters.at(1);
+  if (!listenerDecl) return typeChecker.getAnyType();
+  return typeChecker.getTypeAtLocation(listenerDecl);
+}
+function getUnionType(typeChecker, types) {
+  if ("getUnionType" in typeChecker) {
+    return typeChecker.getUnionType(types);
+  }
+  return types.at(0);
+}
+function getHTMLNodeAtPosition(vHtml, offset) {
+  const node = vHtml.findNodeAt(offset);
+  const attr = node.attributesMap.entries().find(([_, n]) => {
+    return offset > n.start && offset < n.end + 1 + (n.value?.length || 0);
+  });
+  return {
+    node,
+    attrName: attr?.[0] ?? "",
+    attrValue: attr?.[1].value ?? "",
+    attrStart: attr?.[1].start ?? 0,
+    attrEnd: attr?.[1].end ?? 0
+  };
+}
+
+// src/decorate-ts.ts
+function decorateLanguageService(ctx, languageService) {
+  const { ts, getProgram } = ctx;
+  const ls = bindMemberFunction(languageService);
+  languageService.getCompletionsAtPosition = (...args) => {
+    const program = getProgram();
+    const typeChecker = program.getTypeChecker();
+    decorate(typeChecker, () => decorateTypeChecker(typeChecker));
+    const classKeys = getClassKeys(ctx, args[0], args[1]);
+    if (classKeys) {
+      return {
+        isGlobalCompletion: true,
+        isMemberCompletion: true,
+        isNewIdentifierLocation: true,
+        entries: classKeys.map((name) => ({ kind: ts.ScriptElementKind.enumMemberElement, sortText: "", name }))
+      };
+    }
+    const themeKeys = getThemeKeys(ctx, args[0], args[1]);
+    if (themeKeys) {
+      return {
+        isGlobalCompletion: true,
+        isMemberCompletion: true,
+        isNewIdentifierLocation: true,
+        entries: themeKeys.map((name) => ({ kind: ts.ScriptElementKind.enumMemberElement, sortText: "", name }))
+      };
+    }
+    return ls.getCompletionsAtPosition(...args);
+  };
+  languageService.getSyntacticDiagnostics = (...args) => {
+    const program = getProgram();
+    const file = program.getSourceFile(args[0]);
+    ctx.updateElement(file);
+    return ls.getSyntacticDiagnostics(...args);
+  };
+  languageService.getSuggestionDiagnostics = (...args) => {
+    const program = getProgram();
+    const file = program.getSourceFile(args[0]);
+    const result = ls.getSuggestionDiagnostics(...args);
+    ts.forEachChild(file, (node) => {
+      const tag = ctx.getTagFromNode(node);
+      if (tag && ts.isClassDeclaration(node)) {
+        if (node.name && !node.name.text.endsWith("Element")) {
+          result.push({
+            file,
+            start: node.name.getStart(),
+            length: node.name.getEnd() - node.name.getStart(),
+            category: ctx.config.strict ? ts.DiagnosticCategory.Warning : ts.DiagnosticCategory.Suggestion,
+            code: 108 /* SuggestionClassName */,
+            messageText: "Element definition class suggests the suffix to use `Element`"
+          });
+        }
+        const isShadowDom = hasCallDecorator(ts, node, [Decorators.Shadow]);
+        node.members.forEach((member) => {
+          const memberStart = member.getStart();
+          const baseMemberDiagnostic = { file, start: memberStart, length: member.getEnd() - memberStart };
+          if (ctx.config.strict && member.name && ts.isIdentifier(member.name) && member.name.text.length > 3 && member.name.text === member.name.text.toLowerCase() && member.name.text.startsWith("on")) {
+            result.push({
+              ...baseMemberDiagnostic,
+              category: ts.DiagnosticCategory.Warning,
+              code: 110 /* SuggestionPropName */,
+              messageText: "Consider changing the name, it looks too much like the html event handler"
+            });
+          }
+          if (!ts.isPropertyDeclaration(member) || !member.modifiers) return;
+          if (hasDecorator(ts, member, [Decorators.Prop]) && !member.questionToken && !member.initializer) {
+            result.push({
+              ...baseMemberDiagnostic,
+              category: ctx.config.strict ? ts.DiagnosticCategory.Warning : ts.DiagnosticCategory.Suggestion,
+              code: 109 /* SuggestionPropOptional */,
+              messageText: "Custom element property should be optional"
+            });
+          }
+          if (!hasDecorator(ts, member, [Decorators.Slot, Decorators.Part])) return;
+          const missStaticKeyword = member.modifiers.every((e) => e.kind !== ts.SyntaxKind.StaticKeyword);
+          if (missStaticKeyword || !isShadowDom) {
+            result.push({
+              ...baseMemberDiagnostic,
+              category: ts.DiagnosticCategory.Warning,
+              code: 107 /* DecoratorSyntaxError */,
+              messageText: missStaticKeyword ? "Use static field for `@part` and `@slot`" : "Not available on light dom `@part` and `@slot`"
+            });
+          }
+        });
+      }
+    });
+    return result.filter(({ start, reportsUnnecessary, category }) => {
+      if (!reportsUnnecessary || category !== ts.DiagnosticCategory.Suggestion) return true;
+      const node = getAstNodeAtPosition(ts, file, start);
+      const declaration = node?.parent;
+      if (!declaration) return true;
+      if (ts.isClassDeclaration(declaration)) {
+        return !hasCallDecorator(ts, declaration, [Decorators.CustomElement]);
+      }
+      if (ts.isMethodDeclaration(declaration) || ts.isPropertyDeclaration(declaration)) {
+        return !declaration.modifiers?.some((e) => e?.kind === ts.SyntaxKind.Decorator);
+      }
+      return true;
+    });
+  };
+  languageService.findReferences = (...args) => {
+    const map = /* @__PURE__ */ new Map();
+    const tagDefinedInfo = findDefinedTagInfo(ctx, ...args);
+    if (tagDefinedInfo) {
+      forEachAllHtmlTemplateNode(ctx, tagDefinedInfo.tag, (file, tagInfo) => {
+        const symbol = map.get(file.fileName) || getReferencedSymbol(ctx, file);
+        map.set(file.fileName, symbol);
+        symbol.references.push({
+          fileName: file.fileName,
+          isWriteAccess: true,
+          textSpan: tagInfo.open
+        });
+      });
+      forEachAllCssTemplateNode(ctx, tagDefinedInfo.tag, (file, textSpan) => {
+        const symbol = map.get(file.fileName) || getReferencedSymbol(ctx, file);
+        map.set(file.fileName, symbol);
+        symbol.references.push({
+          fileName: file.fileName,
+          isWriteAccess: true,
+          textSpan
+        });
+      });
+      return [...map.values()];
+    }
+    const oResult = ls.findReferences(...args) || [];
+    const program = getProgram();
+    const currentNode = getAstNodeAtPosition(ts, program.getSourceFile(args[0]), args[1]);
+    if (!currentNode || !ts.isIdentifier(currentNode)) return oResult;
+    const currentTag = ctx.getTagFromNode(currentNode.parent) || ctx.getTagFromNode(currentNode.parent.parent);
+    const prop = ts.isClassDeclaration(currentNode.parent.parent) && currentNode;
+    if (!currentTag) return oResult;
+    if (prop) {
+      getAllTagFromProp(ctx, currentNode).forEach((tag) => {
+        forEachAllHtmlTemplateNode(ctx, tag, (file, tagInfo) => {
+          const symbol = map.get(file.fileName) || getReferencedSymbol(ctx, file);
+          map.set(file.fileName, symbol);
+          const propNames = /* @__PURE__ */ new Set([`.${prop.text}`]);
+          const kebabCaseName = camelToKebabCase(prop.text);
+          ["", "?", "@"].forEach((c) => propNames.add(`${c}${kebabCaseName}`));
+          for (const propName of propNames) {
+            const info = tagInfo.node.attributesMap.get(propName);
+            if (!info) continue;
+            const textSpan = { start: info.start + tagInfo.offset, length: info.end - info.start };
+            symbol.references.push({ fileName: file.fileName, isWriteAccess: true, textSpan });
+          }
+        });
+      });
+    }
+    return [...map.values(), ...oResult];
+  };
+  languageService.getDefinitionAndBoundSpan = (...args) => {
+    const classMapKeyInfo = getClassMapKeyInfo(ctx, ...args);
+    const kind = ts.ScriptElementKind.classElement;
+    const containerKind = ts.ScriptElementKind.unknown;
+    const fileName = args[0];
+    if (classMapKeyInfo) {
+      return {
+        textSpan: classMapKeyInfo.textSpan,
+        definitions: classMapKeyInfo.styles.flatMap(({ classIdNodeMap, templateNode }) => {
+          return classIdNodeMap.get(classMapKeyInfo.text)?.map((node) => ({
+            kind,
+            containerKind,
+            fileName,
+            containerName: "",
+            name: "",
+            textSpan: { start: node.offset + templateNode.pos + 1, length: node.getText().length }
+          }));
+        }).filter(isNotNullish)
+      };
+    }
+    const tagDefinedInfo = findDefinedTagInfo(ctx, ...args);
+    if (!tagDefinedInfo) return ls.getDefinitionAndBoundSpan(...args);
+    const textSpan = tagDefinedInfo.textSpan;
+    return {
+      textSpan,
+      definitions: [{ kind, containerKind, fileName, containerName: "", name: "", textSpan }]
+    };
+  };
+  languageService.getRenameInfo = (fileName, position, ...args) => {
+    const tagInfo = findCurrentTagInfo(ctx, fileName, position);
+    if (tagInfo) {
+      return {
+        canRename: true,
+        displayName: tagInfo.tag,
+        fullDisplayName: tagInfo.tag,
+        kind: ts.ScriptElementKind.alias,
+        kindModifiers: "tag",
+        triggerSpan: tagInfo.open
+      };
+    }
+    const tagDefinedInfo = findDefinedTagInfo(ctx, fileName, position);
+    if (tagDefinedInfo) {
+      return {
+        canRename: true,
+        displayName: tagDefinedInfo.tag,
+        fullDisplayName: tagDefinedInfo.tag,
+        kind: ts.ScriptElementKind.alias,
+        kindModifiers: "tag",
+        triggerSpan: tagDefinedInfo.textSpan
+      };
+    }
+    return ls.getRenameInfo(fileName, position, ...args);
+  };
+  languageService.findRenameLocations = (fileName, position, ...args) => {
+    const tagPairInfo = findCurrentTagInfo(ctx, fileName, position);
+    if (tagPairInfo) {
+      const result = [{ fileName, textSpan: tagPairInfo.open }];
+      if (tagPairInfo.end) result.push({ fileName, textSpan: tagPairInfo.end });
+      return result;
+    }
+    const tagDefinedInfo = findDefinedTagInfo(ctx, fileName, position);
+    if (tagDefinedInfo) {
+      const result = [{ fileName, textSpan: tagDefinedInfo.textSpan }];
+      forEachAllHtmlTemplateNode(ctx, tagDefinedInfo.tag, (f, info) => {
+        result.push({ fileName: f.fileName, textSpan: info.open });
+        if (info.end) result.push({ fileName: f.fileName, textSpan: info.end });
+      });
+      forEachAllCssTemplateNode(ctx, tagDefinedInfo.tag, (f, textSpan) => {
+        result.push({ fileName: f.fileName, textSpan });
+      });
+      return result;
+    }
+    const oResult = [...ls.findRenameLocations(fileName, position, ...args) || []];
+    const file = ctx.getProgram().getSourceFile(fileName);
+    const node = getAstNodeAtPosition(ts, file, position);
+    const tag = node && ts.isPropertyDeclaration(node.parent) && ctx.getTagFromNode(node.parent.parent);
+    if (!tag || !ts.isIdentifier(node)) return oResult;
+    const propText = node.getText();
+    const kebabCaseName = camelToKebabCase(propText);
+    if (isPropType(ts, node.parent, [Decorators.Emitter, Decorators.GlobalEmitter])) {
+      getAllTagFromProp(ctx, node).forEach((tag2) => {
+        forEachAllHtmlTemplateNode(ctx, tag2, (f, tagInfo) => {
+          const info = tagInfo.node.attributesMap.get(`@${kebabCaseName}`);
+          if (!info) return;
+          const textSpan = { start: info.start + tagInfo.offset, length: info.end - info.start };
+          oResult.push({ textSpan, fileName: f.fileName, prefixText: "@" });
+        });
+      });
+    }
+    if (isPropType(ts, node.parent, [Decorators.Attr, Decorators.NumAttr, Decorators.BoolAttr, Decorators.Prop])) {
+      getAllTagFromProp(ctx, node).forEach((tag2) => {
+        forEachAllHtmlTemplateNode(ctx, tag2, (f, tagInfo) => {
+          const propNames = [
+            ["", kebabCaseName],
+            ["?", kebabCaseName],
+            [".", propText]
+          ];
+          propNames.map(([decorate2, propName]) => {
+            const info = tagInfo.node.attributesMap.get(decorate2 + propName);
+            if (!info) return;
+            const textSpan = { start: info.start + tagInfo.offset, length: info.end - info.start };
+            oResult.push({ textSpan, fileName: f.fileName, prefixText: decorate2 });
+          });
+        });
+      });
+    }
+    return oResult;
+  };
+  return languageService;
+}
+function getAllTagFromProp(ctx, prop) {
+  let originTagDecl = prop;
+  while (!ctx.ts.isClassDeclaration(originTagDecl)) {
+    originTagDecl = originTagDecl.parent;
+  }
+  const typeChecker = ctx.getProgram().getTypeChecker();
+  const originTagType = typeChecker.getTypeAtLocation(originTagDecl);
+  const result = [];
+  [...ctx.elements].forEach(([tag, decl]) => {
+    const tagType = typeChecker.getTypeAtLocation(decl);
+    if (!tagType.isClassOrInterface()) return;
+    if (typeChecker.isTypeAssignableTo(tagType, originTagType)) {
+      result.push(tag);
+    }
+  });
+  return result;
+}
+function getReferencedSymbol(ctx, file) {
+  return {
+    references: [],
+    definition: {
+      containerKind: ctx.ts.ScriptElementKind.unknown,
+      containerName: "",
+      displayParts: [],
+      fileName: file.fileName,
+      textSpan: { start: 0, length: 0 },
+      name: "test",
+      kind: ctx.ts.ScriptElementKind.unknown
+    }
+  };
+}
+function forEachAllHtmlTemplateNode(ctx, tag, fn) {
+  for (const file of ctx.getProgram().getSourceFiles()) {
+    if (file.fileName.endsWith(".d.ts")) continue;
+    for (const templateContext of ctx.htmlSourceHelper.getAllTemplates(file.fileName)) {
+      const { tagNodeMap } = ctx.getHtmlDoc(templateContext.text);
+      tagNodeMap.get(tag)?.forEach((node) => fn(file, getTagInfo(node, templateContext.node.getStart() + 1)));
+    }
+  }
+}
+function forEachAllCssTemplateNode(ctx, tag, fn) {
+  for (const file of ctx.getProgram().getSourceFiles()) {
+    if (file.fileName.endsWith(".d.ts")) continue;
+    for (const templateContext of ctx.cssSourceHelper.getAllTemplates(file.fileName)) {
+      const { tagNodeMap } = ctx.getCssDoc(templateContext.text);
+      const offset = templateContext.node.getStart() + 1;
+      tagNodeMap.get(tag)?.forEach((node) => fn(file, { start: offset + node.offset, length: node.end - node.offset }));
+    }
+  }
+}
+function findCurrentTagInfo(ctx, fileName, position) {
+  const templateContext = ctx.htmlSourceHelper.getTemplate(fileName, position);
+  if (!templateContext) return;
+  const htmlOffset = templateContext.node.pos + 1;
+  const { vHtml } = ctx.getHtmlDoc(templateContext.text);
+  const relativePosition = ctx.htmlSourceHelper.getRelativePosition(templateContext, position);
+  const offset = templateContext.toOffset(relativePosition);
+  const node = vHtml.findNodeAt(offset);
+  if (node.tag && offset < node.start + 1 + node.tag.length) return getTagInfo(node, htmlOffset);
+}
+function findDefinedTagInfo(ctx, fileName, position) {
+  const file = ctx.getProgram().getSourceFile(fileName);
+  const node = getAstNodeAtPosition(ctx.ts, file, position);
+  if (!node || !ctx.ts.isStringLiteral(node) || !ctx.ts.isCallExpression(node.parent) || node.parent.expression.getText() !== Decorators.CustomElement) {
+    return;
+  }
+  const tag = node.text;
+  return { tag, textSpan: { start: node.getStart() + 1, length: tag.length } };
+}
+function getClassMapKeyInfo(ctx, fileName, position) {
+  const file = ctx.getProgram().getSourceFile(fileName);
+  const node = getAstNodeAtPosition(ctx.ts, file, position);
+  const decl = node && getCurrentElementDecl(ctx.ts, node);
+  if (decl && isClassMapKey(ctx.ts, node)) {
+    const isString = ctx.ts.isStringLiteral(node);
+    return {
+      text: node.text,
+      styles: ctx.getAllCss(decl),
+      textSpan: { start: node.getStart() + (isString ? 1 : 0), length: node.text.length }
+    };
+  }
+}
+function isKey(typescript, node) {
+  if (!node.parent?.parent) return false;
+  const assignment = node.parent;
+  const obj = assignment.parent;
+  const key = typescript.isStringLiteral(node) || typescript.isIdentifier(node);
+  return key && (typescript.isPropertyAssignment(assignment) && assignment.initializer !== node || typescript.isShorthandPropertyAssignment(assignment)) && typescript.isObjectLiteralExpression(obj);
+}
+function inReturn(typescript, node) {
+  if (!node?.parent?.parent) return false;
+  const isReturnObject = (n) => typescript.isObjectLiteralExpression(n) && (typescript.isParenthesizedExpression(n.parent) && typescript.isArrowFunction(n.parent.parent) && n.parent.parent.body === n.parent || typescript.isReturnStatement(n.parent));
+  return (
+    // 空对象
+    isReturnObject(node) || // 在返回对象的 key 上
+    isReturnObject(node.parent.parent) && isKey(typescript, node)
+  );
+}
+function getThemeKeys(ctx, fileName, position) {
+  const program = ctx.getProgram();
+  const typeChecker = program.getTypeChecker();
+  const file = program.getSourceFile(fileName);
+  const node = getAstNodeAtPosition(ctx.ts, file, position);
+  if (!inReturn(ctx.ts, node)) return;
+  let desc = node;
+  while (desc) {
+    if ((ctx.ts.isArrowFunction(desc) || ctx.ts.isFunctionExpression(desc)) && !ctx.ts.isPropertyDeclaration(desc.parent) || ctx.ts.isFunctionDeclaration(desc) || ctx.ts.isClassDeclaration(desc) || ctx.ts.isClassExpression(desc)) {
+      return;
+    }
+    if (ctx.ts.isPropertyDeclaration(desc) || ctx.ts.isMethodDeclaration(desc)) {
+      for (const modifier of desc.modifiers || []) {
+        if (!ctx.ts.isDecorator(modifier) || !ctx.ts.isCallExpression(modifier.expression)) continue;
+        const themeDescSymbol = typeChecker.getSymbolAtLocation(modifier.expression.expression);
+        const themeDesc = themeDescSymbol?.valueDeclaration;
+        const param = themeDesc && ctx.ts.isVariableDeclaration(themeDesc) && themeDesc.initializer && ctx.ts.isCallExpression(themeDesc.initializer) && themeDesc.initializer.expression.getText() === Utils.CreateDecoratorTheme && themeDesc.initializer.arguments.at(0);
+        if (!param) continue;
+        const type = typeChecker.getTypeAtLocation(param);
+        return type.getApparentProperties().map((e) => e.name);
+      }
+      return;
+    }
+    desc = desc.parent;
+  }
+}
+function isClassMap(typescript, node) {
+  if (!node.parent?.parent) return false;
+  const callExp = node.parent;
+  const isEmptyClassMap = typescript.isObjectLiteralExpression(node) && typescript.isCallExpression(callExp) && typescript.isIdentifier(callExp.expression) && callExp.expression.text === Utils.ClassMap;
+  return isEmptyClassMap || isClassMapKey(typescript, node);
+}
+function getCurrentClassMap(typescript, node) {
+  while (!typescript.isObjectLiteralExpression(node)) {
+    node = node.parent;
+    if (!node) return;
+  }
+  return node;
+}
+function getClassKeys(ctx, fileName, position) {
+  const file = ctx.getProgram().getSourceFile(fileName);
+  const node = getAstNodeAtPosition(ctx.ts, file, position);
+  const decl = node && getCurrentElementDecl(ctx.ts, node);
+  if (decl && isClassMap(ctx.ts, node)) {
+    const obj = getCurrentClassMap(ctx.ts, node);
+    const keys2 = new Set(obj.properties.map((e) => e.name?.getText()));
+    return ctx.getAllCss(decl).flatMap(({ classIdNodeMap }) => {
+      return [...classIdNodeMap.entries()].filter(([k]) => !keys2.has(k) && !k.startsWith("#")).map(([k]) => k);
+    });
+  }
+}
+function isPropType(typescript, node, types) {
+  if (!typescript.isPropertyDeclaration(node)) return;
+  for (const modifier of node.modifiers || []) {
+    if (!typescript.isDecorator(modifier)) continue;
+    const { expression } = modifier;
+    if (typescript.isIdentifier(expression) && types.includes(expression.text)) {
+      return true;
+    }
+  }
+}
+function decorateTypeChecker(typeChecker) {
+  const neverType = typeChecker.getNeverType();
+  const internal = typeChecker;
+  const checker = bindMemberFunction(internal, ["isValidPropertyAccessForCompletions"]);
+  internal.isValidPropertyAccessForCompletions = (...args) => {
+    const result = checker.isValidPropertyAccessForCompletions(...args);
+    try {
+      return result && typeChecker.getTypeOfSymbol(args.at(2)) !== neverType;
+    } catch {
+      return result;
+    }
+  };
+  return typeChecker;
+}
+
+// src/index.ts
+var LanguageServiceLogger = class {
+  #info;
+  constructor(info) {
+    this.#info = info;
+  }
+  log(msg) {
+    this.#info.project.projectService.logger.info(`[${NAME}] ${msg}`);
+  }
+};
+var HtmlPlugin = class {
+  #ts;
+  #config = new Configuration();
+  constructor(typescript) {
+    this.#ts = typescript;
+  }
+  create(info) {
+    return decorate(info.languageService, () => {
+      const logger = new LanguageServiceLogger(info);
+      logger.log("Starting...");
+      this.#config.update(info.config);
+      const context = new Context(this.#ts, this.#config, info, logger);
+      const decoratedService = decorateLanguageService(context, info.languageService);
+      const decoratedService1 = (0, import_typescript_template_language_service_decorator.decorateWithTemplateLanguageService)(
+        this.#ts,
+        decoratedService,
+        info.project,
+        new CSSLanguageService(context),
+        context.cssTemplateStringSettings,
+        { logger }
+      );
+      return (0, import_typescript_template_language_service_decorator.decorateWithTemplateLanguageService)(
+        this.#ts,
+        decoratedService1,
+        info.project,
+        new HTMLLanguageService(context),
+        context.htmlTemplateStringSettings,
+        { logger }
+      );
+    });
+  }
+  onConfigurationChanged(config) {
+    this.#config.update(config);
+  }
+};
+module.exports = (mod) => new HtmlPlugin(mod.typescript);
+//# sourceMappingURL=index.js.map