LeetCode Intelligent

为 LeetCode 增加智能代码提示，提供代码补全功能
Ask a question, post a review, or report the script.
// ==UserScript==
// @name         LeetCode Intelligent
// @namespace    https://shiyu.dev/
// @version      0.1
// @description  为 LeetCode 增加智能代码提示，提供代码补全功能
// @author       ShiYu
// @license      MIT
// @match        https://leetcode.com/problems/* 
// @match        https://leetcode.cn/problems/*
// @match        https://www.leetcode.com/problems/* 
// @match        https://www.leetcode.cn/problems/*
// @grant        none
// @antifeature  none
// @run-at       document-end
// ==/UserScript==

// src/cpp/utils.ts
function extractVariables(code, position) {
  const variableRegex = /\b(?:vector|stack|queue|deque|map|unordered_map|set|unordered_set|list|forward_list|multiset|unordered_multiset|multimap|unordered_multimap|priority_queue|pair|tuple|array)\s*<[^>]+>\s+(\w+)\s*;/g;
  const basicTypeRegex = /\b(?:int|float|double|char|bool|string|auto)\s+(\w+)\s*;/g;
  const funcParamRegex = /\(([^)]*)\)/g;
  const variables = new Map;
  const lines = code.split("\n").slice(0, position.lineNumber - 1);
  let currentLine = code.split("\n")[position.lineNumber - 1].substring(0, position.column - 1);
  lines.push(currentLine);
  const codeBeforeCursor = lines.join("\n");
  let match;
  while ((match = variableRegex.exec(codeBeforeCursor)) !== null) {
    const varName = match[1];
    variables.set(varName, { type: "template", kind: "variable" });
  }
  while ((match = basicTypeRegex.exec(codeBeforeCursor)) !== null) {
    const varName = match[1];
    variables.set(varName, { type: "basic", kind: "variable" });
  }
  const funcMatch = funcParamRegex.exec(codeBeforeCursor);
  if (funcMatch) {
    const params = funcMatch[1].split(",");
    params.forEach((param) => {
      const parts = param.trim().split(/\s+/);
      const paramName = parts[parts.length - 1];
      variables.set(paramName, { type: "parameter", kind: "parameter" });
    });
  }
  return variables;
}
function getRange(position, word) {
  return {
    startLineNumber: position.lineNumber,
    endLineNumber: position.lineNumber,
    startColumn: word.startColumn,
    endColumn: word.endColumn
  };
}

// src/cpp/vector.ts
function getVectorSuggestions(monaco, range) {
  return [
    {
      label: "push_back",
      kind: monaco.languages.CompletionItemKind.Method,
      insertText: "push_back(${1:value});",
      insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
      documentation: "Adds an element to the end of the vector.",
      range
    },
    {
      label: "pop_back",
      kind: monaco.languages.CompletionItemKind.Method,
      insertText: "pop_back();",
      documentation: "Removes the last element of the vector.",
      range
    },
    {
      label: "size",
      kind: monaco.languages.CompletionItemKind.Method,
      insertText: "size()",
      documentation: "Returns the number of elements in the vector.",
      range
    },
    {
      label: "clear",
      kind: monaco.languages.CompletionItemKind.Method,
      insertText: "clear();",
      documentation: "Removes all elements from the vector.",
      range
    },
    {
      label: "at",
      kind: monaco.languages.CompletionItemKind.Method,
      insertText: "at(${1:index})",
      insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
      documentation: "Returns a reference to the element at the specified position.",
      range
    },
    {
      label: "empty",
      kind: monaco.languages.CompletionItemKind.Method,
      insertText: "empty()",
      documentation: "Checks if the vector is empty.",
      range
    },
    {
      label: "reserve",
      kind: monaco.languages.CompletionItemKind.Method,
      insertText: "reserve(${1:size});",
      insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
      documentation: "Requests that the vector capacity be at least enough to contain a specified number of elements.",
      range
    },
    {
      label: "capacity",
      kind: monaco.languages.CompletionItemKind.Method,
      insertText: "capacity()",
      documentation: "Returns the number of elements that can be held in currently allocated storage.",
      range
    },
    {
      label: "front",
      kind: monaco.languages.CompletionItemKind.Method,
      insertText: "front()",
      documentation: "Returns a reference to the first element in the vector.",
      range
    },
    {
      label: "back",
      kind: monaco.languages.CompletionItemKind.Method,
      insertText: "back()",
      documentation: "Returns a reference to the last element in the vector.",
      range
    },
    {
      label: "insert",
      kind: monaco.languages.CompletionItemKind.Method,
      insertText: "insert(${1:position}, ${2:value});",
      insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
      documentation: "Inserts elements at the specified position.",
      range
    },
    {
      label: "erase",
      kind: monaco.languages.CompletionItemKind.Method,
      insertText: "erase(${1:position});",
      insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
      documentation: "Erases elements at the specified position.",
      range
    },
    {
      label: "resize",
      kind: monaco.languages.CompletionItemKind.Method,
      insertText: "resize(${1:new_size});",
      insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
      documentation: "Resizes the container to contain the specified number of elements.",
      range
    },
    {
      label: "shrink_to_fit",
      kind: monaco.languages.CompletionItemKind.Method,
      insertText: "shrink_to_fit();",
      documentation: "Reduces the capacity of the vector to fit its size.",
      range
    },
    {
      label: "data",
      kind: monaco.languages.CompletionItemKind.Method,
      insertText: "data()",
      documentation: "Returns a direct pointer to the memory array used internally by the vector to store its owned elements.",
      range
    },
    {
      label: "emplace_back",
      kind: monaco.languages.CompletionItemKind.Method,
      insertText: "emplace_back(${1:args});",
      insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
      documentation: "Constructs and inserts a new element at the end of the vector.",
      range
    }
  ];
}

// src/cpp/stack.ts
function getStackSuggestions(monaco, range) {
  return [
    {
      label: "push",
      kind: monaco.languages.CompletionItemKind.Method,
      insertText: "push(${1:value});",
      insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
      documentation: "Pushes an element onto the stack.",
      range
    },
    {
      label: "pop",
      kind: monaco.languages.CompletionItemKind.Method,
      insertText: "pop();",
      documentation: "Removes the top element of the stack.",
      range
    },
    {
      label: "top",
      kind: monaco.languages.CompletionItemKind.Method,
      insertText: "top()",
      documentation: "Returns a reference to the top element of the stack.",
      range
    },
    {
      label: "empty",
      kind: monaco.languages.CompletionItemKind.Method,
      insertText: "empty()",
      documentation: "Checks whether the stack is empty.",
      range
    },
    {
      label: "size",
      kind: monaco.languages.CompletionItemKind.Method,
      insertText: "size()",
      documentation: "Returns the number of elements in the stack.",
      range
    },
    {
      label: "emplace",
      kind: monaco.languages.CompletionItemKind.Method,
      insertText: "emplace(${1:args});",
      insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
      documentation: "Constructs and inserts an element at the top of the stack.",
      range
    },
    {
      label: "swap",
      kind: monaco.languages.CompletionItemKind.Method,
      insertText: "swap(${1:other_stack});",
      insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
      documentation: "Exchanges the contents of the container with another stack.",
      range
    }
  ];
}

// src/cpp/queue.ts
function getQueueSuggestions(monaco, range) {
  return [
    {
      label: "push",
      kind: monaco.languages.CompletionItemKind.Method,
      insertText: "push(${1:value});",
      insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
      documentation: "Inserts an element at the end of the queue.",
      range
    },
    {
      label: "pop",
      kind: monaco.languages.CompletionItemKind.Method,
      insertText: "pop();",
      documentation: "Removes the next element in the queue.",
      range
    },
    {
      label: "front",
      kind: monaco.languages.CompletionItemKind.Method,
      insertText: "front()",
      documentation: "Accesses the next element in the queue.",
      range
    },
    {
      label: "back",
      kind: monaco.languages.CompletionItemKind.Method,
      insertText: "back()",
      documentation: "Accesses the last element in the queue.",
      range
    },
    {
      label: "empty",
      kind: monaco.languages.CompletionItemKind.Method,
      insertText: "empty()",
      documentation: "Checks if the queue is empty.",
      range
    },
    {
      label: "size",
      kind: monaco.languages.CompletionItemKind.Method,
      insertText: "size()",
      documentation: "Returns the number of elements in the queue.",
      range
    },
    {
      label: "emplace",
      kind: monaco.languages.CompletionItemKind.Method,
      insertText: "emplace(${1:args});",
      insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
      documentation: "Constructs and inserts a new element at the end of the queue.",
      range
    },
    {
      label: "swap",
      kind: monaco.languages.CompletionItemKind.Method,
      insertText: "swap(${1:other_queue});",
      insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
      documentation: "Exchanges the contents of the queue with another.",
      range
    }
  ];
}

// src/cpp/generalSuggestions.ts
function getGeneralSuggestions(monaco, range) {
  return [
    {
      label: "cout",
      kind: monaco.languages.CompletionItemKind.Snippet,
      insertText: "cout << $1 << endl;",
      insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
      documentation: "Standard output stream",
      range
    },
    {
      label: "cin",
      kind: monaco.languages.CompletionItemKind.Snippet,
      insertText: "cin >> $1;",
      insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
      documentation: "Standard input stream",
      range
    },
    {
      label: "for (auto x : num)",
      kind: monaco.languages.CompletionItemKind.Snippet,
      insertText: "for (auto ${1:x} : ${2:container}) {\n\t$0\n}",
      insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
      documentation: "Range-based for loop using auto",
      range
    },
    {
      label: "for",
      kind: monaco.languages.CompletionItemKind.Snippet,
      insertText: "for (int ${1:i} = 0; ${1:i} < ${2:n}; ${1:i}++) {\n\t$0\n}",
      insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
      documentation: "For loop",
      range
    },
    {
      label: "while",
      kind: monaco.languages.CompletionItemKind.Snippet,
      insertText: "while (${1:condition}) {\n\t$0\n}",
      insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
      documentation: "While loop",
      range
    },
    {
      label: "vector",
      kind: monaco.languages.CompletionItemKind.Snippet,
      insertText: "vector<${1:int}> ${2:vec};",
      insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
      documentation: "Creates a std::vector",
      range
    },
    {
      label: "stack",
      kind: monaco.languages.CompletionItemKind.Snippet,
      insertText: "stack<${1:int}> ${2:stk};",
      insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
      documentation: "Creates a std::stack",
      range
    },
    {
      label: "queue",
      kind: monaco.languages.CompletionItemKind.Snippet,
      insertText: "queue<${1:int}> ${2:q};",
      insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
      documentation: "Creates a std::queue",
      range
    },
    {
      label: "deque",
      kind: monaco.languages.CompletionItemKind.Snippet,
      insertText: "deque<${1:int}> ${2:dq};",
      insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
      documentation: "Creates a std::deque",
      range
    },
    {
      label: "map",
      kind: monaco.languages.CompletionItemKind.Snippet,
      insertText: "map<${1:int}, ${2:int}> ${3:m};",
      insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
      documentation: "Creates a std::map",
      range
    },
    {
      label: "unordered_map",
      kind: monaco.languages.CompletionItemKind.Snippet,
      insertText: "unordered_map<${1:int}, ${2:int}> ${3:umap};",
      insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
      documentation: "Creates a std::unordered_map",
      range
    },
    {
      label: "set",
      kind: monaco.languages.CompletionItemKind.Snippet,
      insertText: "set<${1:int}> ${2:s};",
      insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
      documentation: "Creates a std::set",
      range
    },
    {
      label: "unordered_set",
      kind: monaco.languages.CompletionItemKind.Snippet,
      insertText: "unordered_set<${1:int}> ${2:uset};",
      insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
      documentation: "Creates a std::unordered_set",
      range
    },
    {
      label: "multimap",
      kind: monaco.languages.CompletionItemKind.Snippet,
      insertText: "multimap<${1:int}, ${2:int}> ${3:mm};",
      insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
      documentation: "Creates a std::multimap",
      range
    },
    {
      label: "multiset",
      kind: monaco.languages.CompletionItemKind.Snippet,
      insertText: "multiset<${1:int}> ${2:ms};",
      insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
      documentation: "Creates a std::multiset",
      range
    },
    {
      label: "priority_queue",
      kind: monaco.languages.CompletionItemKind.Snippet,
      insertText: "priority_queue<${1:int}> ${2:pq};",
      insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
      documentation: "Creates a std::priority_queue",
      range
    },
    {
      label: "array",
      kind: monaco.languages.CompletionItemKind.Snippet,
      insertText: "array<${1:int}, ${2:N}> ${3:arr};",
      insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
      documentation: "Creates a std::array",
      range
    },
    {
      label: "pair",
      kind: monaco.languages.CompletionItemKind.Snippet,
      insertText: "pair<${1:int}, ${2:int}> ${3:p};",
      insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
      documentation: "Creates a std::pair",
      range
    },
    {
      label: "forward_list",
      kind: monaco.languages.CompletionItemKind.Snippet,
      insertText: "forward_list<${1:int}> ${2:fl};",
      insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
      documentation: "Creates a std::forward_list",
      range
    },
    {
      label: "unordered_multimap",
      kind: monaco.languages.CompletionItemKind.Snippet,
      insertText: "unordered_multimap<${1:int}, ${2:int}> ${3:umm};",
      insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
      documentation: "Creates a std::unordered_multimap",
      range
    },
    {
      label: "unordered_multiset",
      kind: monaco.languages.CompletionItemKind.Snippet,
      insertText: "unordered_multiset<${1:int}> ${2:ums};",
      insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
      documentation: "Creates a std::unordered_multiset",
      range
    },
    {
      label: "tuple",
      kind: monaco.languages.CompletionItemKind.Snippet,
      insertText: "tuple<${1:int}, ${2:int}, ${3:int}> ${4:tup};",
      insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
      documentation: "Creates a std::tuple",
      range
    },
    {
      label: "sort",
      kind: monaco.languages.CompletionItemKind.Function,
      insertText: "sort(${1:begin}, ${2:end});",
      insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
      documentation: "Sorts the range [begin, end).",
      range
    },
    {
      label: "max",
      kind: monaco.languages.CompletionItemKind.Function,
      insertText: "max(${1:a}, ${2:b});",
      insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
      documentation: "Returns the maximum of two values.",
      range
    },
    {
      label: "min",
      kind: monaco.languages.CompletionItemKind.Function,
      insertText: "min(${1:a}, ${2:b});",
      insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
      documentation: "Returns the minimum of two values.",
      range
    },
    {
      label: "reverse",
      kind: monaco.languages.CompletionItemKind.Function,
      insertText: "reverse(${1:begin}, ${2:end});",
      insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
      documentation: "Reverses the range [begin, end).",
      range
    },
    {
      label: "find",
      kind: monaco.languages.CompletionItemKind.Function,
      insertText: "find(${1:begin}, ${2:end}, ${3:value});",
      insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
      documentation: "Finds the first occurrence of value in the range [begin, end).",
      range
    },
    {
      label: "accumulate",
      kind: monaco.languages.CompletionItemKind.Function,
      insertText: "accumulate(${1:begin}, ${2:end}, ${3:init});",
      insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
      documentation: "Accumulates the sum of the range [begin, end) starting from init.",
      range
    },
    {
      label: "binary_search",
      kind: monaco.languages.CompletionItemKind.Function,
      insertText: "binary_search(${1:begin}, ${2:end}, ${3:value});",
      insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
      documentation: "Checks if value exists in the sorted range [begin, end).",
      range
    },
    {
      label: "lower_bound",
      kind: monaco.languages.CompletionItemKind.Function,
      insertText: "lower_bound(${1:begin}, ${2:end}, ${3:value});",
      insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
      documentation: "Returns an iterator pointing to the first element not less than value in the sorted range [begin, end).",
      range
    },
    {
      label: "upper_bound",
      kind: monaco.languages.CompletionItemKind.Function,
      insertText: "upper_bound(${1:begin}, ${2:end}, ${3:value});",
      insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
      documentation: "Returns an iterator pointing to the first element greater than value in the sorted range [begin, end).",
      range
    },
    {
      label: "unique",
      kind: monaco.languages.CompletionItemKind.Function,
      insertText: "unique(${1:begin}, ${2:end});",
      insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
      documentation: "Removes consecutive duplicates in the range [begin, end).",
      range
    }
  ];
}

// src/cpp/deque.ts
function getDequeSuggestions(monaco, range) {
  return [
    {
      label: "push_back",
      kind: monaco.languages.CompletionItemKind.Method,
      insertText: "push_back(${1:value});",
      insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
      documentation: "Adds an element to the end of the deque.",
      range
    },
    {
      label: "push_front",
      kind: monaco.languages.CompletionItemKind.Method,
      insertText: "push_front(${1:value});",
      insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
      documentation: "Adds an element to the front of the deque.",
      range
    },
    {
      label: "pop_back",
      kind: monaco.languages.CompletionItemKind.Method,
      insertText: "pop_back();",
      documentation: "Removes the last element of the deque.",
      range
    },
    {
      label: "pop_front",
      kind: monaco.languages.CompletionItemKind.Method,
      insertText: "pop_front();",
      documentation: "Removes the first element of the deque.",
      range
    },
    {
      label: "size",
      kind: monaco.languages.CompletionItemKind.Method,
      insertText: "size()",
      documentation: "Returns the number of elements in the deque.",
      range
    },
    {
      label: "clear",
      kind: monaco.languages.CompletionItemKind.Method,
      insertText: "clear();",
      documentation: "Removes all elements from the deque.",
      range
    },
    {
      label: "at",
      kind: monaco.languages.CompletionItemKind.Method,
      insertText: "at(${1:index})",
      insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
      documentation: "Returns a reference to the element at the specified position.",
      range
    },
    {
      label: "empty",
      kind: monaco.languages.CompletionItemKind.Method,
      insertText: "empty()",
      documentation: "Checks if the deque is empty.",
      range
    },
    {
      label: "front",
      kind: monaco.languages.CompletionItemKind.Method,
      insertText: "front()",
      documentation: "Returns a reference to the first element in the deque.",
      range
    },
    {
      label: "back",
      kind: monaco.languages.CompletionItemKind.Method,
      insertText: "back()",
      documentation: "Returns a reference to the last element in the deque.",
      range
    },
    {
      label: "insert",
      kind: monaco.languages.CompletionItemKind.Method,
      insertText: "insert(${1:position}, ${2:value});",
      insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
      documentation: "Inserts elements at the specified position.",
      range
    },
    {
      label: "erase",
      kind: monaco.languages.CompletionItemKind.Method,
      insertText: "erase(${1:position});",
      insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
      documentation: "Erases elements at the specified position.",
      range
    },
    {
      label: "resize",
      kind: monaco.languages.CompletionItemKind.Method,
      insertText: "resize(${1:new_size});",
      insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
      documentation: "Resizes the container to contain the specified number of elements.",
      range
    },
    {
      label: "shrink_to_fit",
      kind: monaco.languages.CompletionItemKind.Method,
      insertText: "shrink_to_fit();",
      documentation: "Reduces the capacity of the deque to fit its size.",
      range
    },
    {
      label: "data",
      kind: monaco.languages.CompletionItemKind.Method,
      insertText: "data()",
      documentation: "Returns a direct pointer to the memory array used internally by the deque.",
      range
    }
  ];
}

// src/cpp/map.ts
function getMapSuggestions(monaco, range) {
  return [
    {
      label: "insert",
      kind: monaco.languages.CompletionItemKind.Method,
      insertText: "insert(${1:pair});",
      insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
      documentation: "Inserts a pair (key, value) into the map.",
      range
    },
    {
      label: "erase",
      kind: monaco.languages.CompletionItemKind.Method,
      insertText: "erase(${1:key});",
      insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
      documentation: "Erases the element by key from the map.",
      range
    },
    {
      label: "find",
      kind: monaco.languages.CompletionItemKind.Method,
      insertText: "find(${1:key})",
      insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
      documentation: "Finds an element by its key.",
      range
    },
    {
      label: "size",
      kind: monaco.languages.CompletionItemKind.Method,
      insertText: "size()",
      documentation: "Returns the number of elements in the map.",
      range
    },
    {
      label: "clear",
      kind: monaco.languages.CompletionItemKind.Method,
      insertText: "clear();",
      documentation: "Removes all elements from the map.",
      range
    },
    {
      label: "empty",
      kind: monaco.languages.CompletionItemKind.Method,
      insertText: "empty()",
      documentation: "Checks if the map is empty.",
      range
    },
    {
      label: "at",
      kind: monaco.languages.CompletionItemKind.Method,
      insertText: "at(${1:key})",
      insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
      documentation: "Accesses an element by key and returns a reference to its value.",
      range
    },
    {
      label: "count",
      kind: monaco.languages.CompletionItemKind.Method,
      insertText: "count(${1:key})",
      documentation: "Returns the number of elements matching the key (either 0 or 1 in a map).",
      range
    }
  ];
}

// src/cpp/unordered_map.ts
function getUnorderedMapSuggestions(monaco, range) {
  return [
    {
      label: "insert",
      kind: monaco.languages.CompletionItemKind.Method,
      insertText: "insert(${1:pair});",
      insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
      documentation: "Inserts a pair (key, value) into the unordered_map.",
      range
    },
    {
      label: "erase",
      kind: monaco.languages.CompletionItemKind.Method,
      insertText: "erase(${1:key});",
      insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
      documentation: "Erases the element by key from the unordered_map.",
      range
    },
    {
      label: "find",
      kind: monaco.languages.CompletionItemKind.Method,
      insertText: "find(${1:key})",
      insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
      documentation: "Finds an element by its key.",
      range
    },
    {
      label: "size",
      kind: monaco.languages.CompletionItemKind.Method,
      insertText: "size()",
      documentation: "Returns the number of elements in the unordered_map.",
      range
    },
    {
      label: "clear",
      kind: monaco.languages.CompletionItemKind.Method,
      insertText: "clear();",
      documentation: "Removes all elements from the unordered_map.",
      range
    },
    {
      label: "empty",
      kind: monaco.languages.CompletionItemKind.Method,
      insertText: "empty()",
      documentation: "Checks if the unordered_map is empty.",
      range
    },
    {
      label: "at",
      kind: monaco.languages.CompletionItemKind.Method,
      insertText: "at(${1:key})",
      insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
      documentation: "Accesses an element by key and returns a reference to its value.",
      range
    },
    {
      label: "count",
      kind: monaco.languages.CompletionItemKind.Method,
      insertText: "count(${1:key})",
      documentation: "Returns the number of elements matching the key (either 0 or 1 in an unordered_map).",
      range
    }
  ];
}

// src/cpp/index.ts
function initCppCompletion(monaco) {
  monaco.languages.registerCompletionItemProvider("cpp", {
    provideCompletionItems: (model, position) => {
      const word = model.getWordUntilPosition(position);
      const range = getRange(position, word);
      const code = model.getValue();
      const variables = extractVariables(code, position);
      const variableSuggestions = [];
      variables.forEach(({ type }, name) => {
        variableSuggestions.push({
          label: name,
          kind: monaco.languages.CompletionItemKind.Variable,
          insertText: name,
          documentation: `Variable of type ${type}`,
          range
        });
      });
      const lineContent = model.getLineContent(position.lineNumber);
      const textBeforeCursor = lineContent.substring(0, position.column - 1).trim();
      const lastDotIndex = textBeforeCursor.lastIndexOf(".");
      let functionSuggestions = [];
      let isDotAfterVariable = false;
      if (lastDotIndex !== -1) {
        const varName = textBeforeCursor.substring(0, lastDotIndex).trim();
        if (variables.has(varName)) {
          const varInfo = variables.get(varName);
          isDotAfterVariable = true;
          switch (varInfo?.type) {
            case "template":
              functionSuggestions = getVectorSuggestions(monaco, range);
              break;
            case "stack":
              functionSuggestions = getStackSuggestions(monaco, range);
              break;
            case "queue":
              functionSuggestions = getQueueSuggestions(monaco, range);
              break;
            case "deque":
              functionSuggestions = getDequeSuggestions(monaco, range);
              break;
            case "map":
              functionSuggestions = getMapSuggestions(monaco, range);
              break;
            case "unordered_map":
              functionSuggestions = getUnorderedMapSuggestions(monaco, range);
              break;
            default:
              break;
          }
        }
      }
      if (!isDotAfterVariable) {
        const generalSuggestions = getGeneralSuggestions(monaco, range);
        return {
          suggestions: [...generalSuggestions, ...variableSuggestions]
        };
      } else {
        return {
          suggestions: [...functionSuggestions]
        };
      }
    }
  });
}

// src/java/arrayList.ts
function getArrayListSuggestions(monaco, range) {
  return [
    {
      label: "add",
      kind: monaco.languages.CompletionItemKind.Method,
      insertText: "add(${1:element});",
      insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
      documentation: "Adds an element to the ArrayList.",
      range
    },
    {
      label: "remove",
      kind: monaco.languages.CompletionItemKind.Method,
      insertText: "remove(${1:index});",
      documentation: "Removes the element at the specified index.",
      range
    },
    {
      label: "get",
      kind: monaco.languages.CompletionItemKind.Method,
      insertText: "get(${1:index});",
      documentation: "Returns the element at the specified index.",
      range
    },
    {
      label: "set",
      kind: monaco.languages.CompletionItemKind.Method,
      insertText: "set(${1:index}, ${2:element});",
      insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
      documentation: "Replaces the element at the specified index with the specified element.",
      range
    },
    {
      label: "size",
      kind: monaco.languages.CompletionItemKind.Method,
      insertText: "size();",
      documentation: "Returns the number of elements in the ArrayList.",
      range
    },
    {
      label: "clear",
      kind: monaco.languages.CompletionItemKind.Method,
      insertText: "clear();",
      documentation: "Removes all elements from the ArrayList.",
      range
    },
    {
      label: "contains",
      kind: monaco.languages.CompletionItemKind.Method,
      insertText: "contains(${1:element});",
      insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
      documentation: "Returns true if this list contains the specified element.",
      range
    },
    {
      label: "indexOf",
      kind: monaco.languages.CompletionItemKind.Method,
      insertText: "indexOf(${1:element});",
      insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
      documentation: "Returns the index of the first occurrence of the specified element, or -1 if this list does not contain the element.",
      range
    },
    {
      label: "lastIndexOf",
      kind: monaco.languages.CompletionItemKind.Method,
      insertText: "lastIndexOf(${1:element});",
      insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
      documentation: "Returns the index of the last occurrence of the specified element, or -1 if this list does not contain the element.",
      range
    },
    {
      label: "isEmpty",
      kind: monaco.languages.CompletionItemKind.Method,
      insertText: "isEmpty();",
      documentation: "Returns true if this list contains no elements.",
      range
    },
    {
      label: "toArray",
      kind: monaco.languages.CompletionItemKind.Method,
      insertText: "toArray();",
      documentation: "Returns an array containing all of the elements in this list in proper sequence.",
      range
    }
  ];
}

// src/java/hashMap.ts
function getHashMapSuggestions(monaco, range) {
  return [
    {
      label: "put",
      kind: monaco.languages.CompletionItemKind.Method,
      insertText: "put(${1:key}, ${2:value});",
      insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
      documentation: "Associates the specified value with the specified key in this map.",
      range
    },
    {
      label: "get",
      kind: monaco.languages.CompletionItemKind.Method,
      insertText: "get(${1:key});",
      documentation: "Returns the value to which the specified key is mapped, or null if this map contains no mapping for the key.",
      range
    },
    {
      label: "remove",
      kind: monaco.languages.CompletionItemKind.Method,
      insertText: "remove(${1:key});",
      documentation: "Removes the mapping for the specified key from this map if present.",
      range
    },
    {
      label: "containsKey",
      kind: monaco.languages.CompletionItemKind.Method,
      insertText: "containsKey(${1:key});",
      documentation: "Returns true if this map contains a mapping for the specified key.",
      range
    },
    {
      label: "containsValue",
      kind: monaco.languages.CompletionItemKind.Method,
      insertText: "containsValue(${1:value});",
      insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
      documentation: "Returns true if this map maps one or more keys to the specified value.",
      range
    },
    {
      label: "keySet",
      kind: monaco.languages.CompletionItemKind.Method,
      insertText: "keySet();",
      documentation: "Returns a Set view of the keys contained in this map.",
      range
    },
    {
      label: "size",
      kind: monaco.languages.CompletionItemKind.Method,
      insertText: "size();",
      documentation: "Returns the number of key-value mappings in this map.",
      range
    },
    {
      label: "clear",
      kind: monaco.languages.CompletionItemKind.Method,
      insertText: "clear();",
      documentation: "Removes all of the mappings from this map. The map will be empty after this call.",
      range
    },
    {
      label: "values",
      kind: monaco.languages.CompletionItemKind.Method,
      insertText: "values();",
      documentation: "Returns a Collection view of the values contained in this map.",
      range
    },
    {
      label: "entrySet",
      kind: monaco.languages.CompletionItemKind.Method,
      insertText: "entrySet();",
      documentation: "Returns a Set view of the mappings contained in this map.",
      range
    }
  ];
}

// src/java/list.ts
function getListSuggestions(monaco, range) {
  return [
    {
      label: "add",
      kind: monaco.languages.CompletionItemKind.Method,
      insertText: "add(${1:element});",
      insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
      documentation: "Appends the specified element to the end of this list.",
      range
    },
    {
      label: "get",
      kind: monaco.languages.CompletionItemKind.Method,
      insertText: "get(${1:index});",
      documentation: "Returns the element at the specified position in this list.",
      range
    },
    {
      label: "remove",
      kind: monaco.languages.CompletionItemKind.Method,
      insertText: "remove(${1:index});",
      documentation: "Removes the element at the specified position in this list.",
      range
    },
    {
      label: "size",
      kind: monaco.languages.CompletionItemKind.Method,
      insertText: "size();",
      documentation: "Returns the number of elements in this list.",
      range
    }
  ];
}

// src/java/set.ts
function getSetSuggestions(monaco, range) {
  return [
    {
      label: "add",
      kind: monaco.languages.CompletionItemKind.Method,
      insertText: "add(${1:element});",
      insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
      documentation: "Adds the specified element to this set if it is not already present.",
      range
    },
    {
      label: "contains",
      kind: monaco.languages.CompletionItemKind.Method,
      insertText: "contains(${1:element});",
      documentation: "Returns true if this set contains the specified element.",
      range
    },
    {
      label: "remove",
      kind: monaco.languages.CompletionItemKind.Method,
      insertText: "remove(${1:element});",
      documentation: "Removes the specified element from this set if it is present.",
      range
    },
    {
      label: "size",
      kind: monaco.languages.CompletionItemKind.Method,
      insertText: "size();",
      documentation: "Returns the number of elements in this set.",
      range
    }
  ];
}

// src/java/queue.ts
function getQueueSuggestions2(monaco, range) {
  return [
    {
      label: "offer",
      kind: monaco.languages.CompletionItemKind.Method,
      insertText: "offer(${1:element});",
      insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
      documentation: "Inserts the specified element into this queue.",
      range
    },
    {
      label: "poll",
      kind: monaco.languages.CompletionItemKind.Method,
      insertText: "poll();",
      documentation: "Retrieves and removes the head of this queue, or returns null if this queue is empty.",
      range
    },
    {
      label: "peek",
      kind: monaco.languages.CompletionItemKind.Method,
      insertText: "peek();",
      documentation: "Retrieves, but does not remove, the head of this queue, or returns null if this queue is empty.",
      range
    },
    {
      label: "size",
      kind: monaco.languages.CompletionItemKind.Method,
      insertText: "size();",
      documentation: "Returns the number of elements in this queue.",
      range
    }
  ];
}

// src/java/stack.ts
function getStackSuggestions2(monaco, range) {
  return [
    {
      label: "push",
      kind: monaco.languages.CompletionItemKind.Method,
      insertText: "push(${1:element});",
      insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
      documentation: "Pushes an item onto the top of this stack.",
      range
    },
    {
      label: "pop",
      kind: monaco.languages.CompletionItemKind.Method,
      insertText: "pop();",
      documentation: "Removes the object at the top of this stack and returns that object as the value of this function.",
      range
    },
    {
      label: "peek",
      kind: monaco.languages.CompletionItemKind.Method,
      insertText: "peek();",
      documentation: "Looks at the object at the top of this stack without removing it from the stack.",
      range
    },
    {
      label: "size",
      kind: monaco.languages.CompletionItemKind.Method,
      insertText: "size();",
      documentation: "Returns the number of elements in this stack.",
      range
    }
  ];
}

// src/java/deque.ts
function getDequeSuggestions2(monaco, range) {
  return [
    {
      label: "addFirst",
      kind: monaco.languages.CompletionItemKind.Method,
      insertText: "addFirst(${1:element});",
      insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
      documentation: "Inserts the specified element at the front of this deque.",
      range
    },
    {
      label: "addLast",
      kind: monaco.languages.CompletionItemKind.Method,
      insertText: "addLast(${1:element});",
      insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
      documentation: "Inserts the specified element at the end of this deque.",
      range
    },
    {
      label: "removeFirst",
      kind: monaco.languages.CompletionItemKind.Method,
      insertText: "removeFirst();",
      documentation: "Removes and returns the first element from this deque.",
      range
    },
    {
      label: "removeLast",
      kind: monaco.languages.CompletionItemKind.Method,
      insertText: "removeLast();",
      documentation: "Removes and returns the last element from this deque.",
      range
    },
    {
      label: "size",
      kind: monaco.languages.CompletionItemKind.Method,
      insertText: "size();",
      documentation: "Returns the number of elements in this deque.",
      range
    }
  ];
}

// src/java/utils.ts
function extractJavaVariables(code, position) {
  const variableRegex = /\b(?:ArrayList|List|Set|Map|Queue|Stack|Deque|LinkedList|HashMap|HashSet|TreeMap|TreeSet|PriorityQueue)\s*<[^>]+>\s+(\w+)\s*=/g;
  const basicTypeRegex = /\b(?:int|float|double|char|boolean|String|byte|short|long)\s+(\w+)\s*;/g;
  const funcParamRegex = /\(([^)]*)\)/g;
  const variables = new Map;
  const lines = code.split("\n").slice(0, position.lineNumber - 1);
  let currentLine = code.split("\n")[position.lineNumber - 1].substring(0, position.column - 1);
  lines.push(currentLine);
  const codeBeforeCursor = lines.join("\n");
  let match;
  while ((match = variableRegex.exec(codeBeforeCursor)) !== null) {
    const varName = match[1];
    variables.set(varName, { type: "ArrayList", kind: "variable" });
  }
  while ((match = basicTypeRegex.exec(codeBeforeCursor)) !== null) {
    const varName = match[1];
    variables.set(varName, { type: "basic", kind: "variable" });
  }
  const funcMatch = funcParamRegex.exec(codeBeforeCursor);
  if (funcMatch) {
    const params = funcMatch[1].split(",");
    params.forEach((param) => {
      const parts = param.trim().split(/\s+/);
      const paramName = parts[parts.length - 1];
      variables.set(paramName, { type: "parameter", kind: "parameter" });
    });
  }
  return variables;
}
function getJavaRange(position, word) {
  return {
    startLineNumber: position.lineNumber,
    endLineNumber: position.lineNumber,
    startColumn: word.startColumn,
    endColumn: word.endColumn
  };
}

// src/java/getGeneralSuggestions.ts
function getGeneralSuggestions2(monaco, range) {
  return [
    {
      label: "System.out.println",
      kind: monaco.languages.CompletionItemKind.Snippet,
      insertText: "System.out.println(${1:message});",
      insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
      documentation: "Prints a message to the standard output",
      range
    },
    {
      label: "for (int i = 0; i < n; i++)",
      kind: monaco.languages.CompletionItemKind.Snippet,
      insertText: "for (int ${1:i} = 0; ${1:i} < ${2:n}; ${1:i}++) {\n\t$0\n}",
      insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
      documentation: "Basic for loop",
      range
    },
    {
      label: "while",
      kind: monaco.languages.CompletionItemKind.Snippet,
      insertText: "while (${1:condition}) {\n\t$0\n}",
      insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
      documentation: "While loop",
      range
    },
    {
      label: "if",
      kind: monaco.languages.CompletionItemKind.Snippet,
      insertText: "if (${1:condition}) {\n\t$0\n}",
      insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
      documentation: "If statement",
      range
    },
    {
      label: "ArrayList",
      kind: monaco.languages.CompletionItemKind.Snippet,
      insertText: "ArrayList<${1:type}> ${2:list} = new ArrayList<>();",
      insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
      documentation: "Creates an ArrayList",
      range
    },
    {
      label: "HashMap",
      kind: monaco.languages.CompletionItemKind.Snippet,
      insertText: "HashMap<${1:K}, ${2:V}> ${3:map} = new HashMap<>();",
      insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
      documentation: "Creates a HashMap",
      range
    },
    {
      label: "HashSet",
      kind: monaco.languages.CompletionItemKind.Snippet,
      insertText: "HashSet<${1:type}> ${2:set} = new HashSet<>();",
      insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
      documentation: "Creates a HashSet",
      range
    },
    {
      label: "LinkedList",
      kind: monaco.languages.CompletionItemKind.Snippet,
      insertText: "LinkedList<${1:type}> ${2:list} = new LinkedList<>();",
      insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
      documentation: "Creates a LinkedList",
      range
    },
    {
      label: "Stack",
      kind: monaco.languages.CompletionItemKind.Snippet,
      insertText: "Stack<${1:type}> ${2:stack} = new Stack<>();",
      insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
      documentation: "Creates a Stack",
      range
    },
    {
      label: "Queue",
      kind: monaco.languages.CompletionItemKind.Snippet,
      insertText: "Queue<${1:type}> ${2:queue} = new LinkedList<>(); // \u4F7F\u7528 LinkedList \u5B9E\u73B0\u961F\u5217",
      insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
      documentation: "Creates a Queue",
      range
    },
    {
      label: "PriorityQueue",
      kind: monaco.languages.CompletionItemKind.Snippet,
      insertText: "PriorityQueue<${1:type}> ${2:pq} = new PriorityQueue<>();",
      insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
      documentation: "Creates a PriorityQueue",
      range
    },
    {
      label: "Deque",
      kind: monaco.languages.CompletionItemKind.Snippet,
      insertText: "Deque<${1:type}> ${2:deque} = new ArrayDeque<>();",
      insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
      documentation: "Creates a Deque",
      range
    },
    {
      label: "Set",
      kind: monaco.languages.CompletionItemKind.Snippet,
      insertText: "Set<${1:type}> ${2:set} = new HashSet<>();",
      insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
      documentation: "Creates a Set",
      range
    },
    {
      label: "TreeMap",
      kind: monaco.languages.CompletionItemKind.Snippet,
      insertText: "TreeMap<${1:K}, ${2:V}> ${3:map} = new TreeMap<>();",
      insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
      documentation: "Creates a TreeMap",
      range
    },
    {
      label: "TreeSet",
      kind: monaco.languages.CompletionItemKind.Snippet,
      insertText: "TreeSet<${1:type}> ${2:set} = new TreeSet<>();",
      insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
      documentation: "Creates a TreeSet",
      range
    }
  ];
}

// src/java/index.ts
function initJavaCompletion(monaco) {
  monaco.languages.registerCompletionItemProvider("java", {
    provideCompletionItems: (model, position) => {
      const word = model.getWordUntilPosition(position);
      const range = getJavaRange(position, word);
      const code = model.getValue();
      const variables = extractJavaVariables(code, position);
      const variableSuggestions = [];
      variables.forEach(({ type }, name) => {
        variableSuggestions.push({
          label: name,
          kind: monaco.languages.CompletionItemKind.Variable,
          insertText: name,
          documentation: `Variable of type ${type}`,
          range
        });
      });
      const lineContent = model.getLineContent(position.lineNumber);
      const textBeforeCursor = lineContent.substring(0, position.column - 1).trim();
      const lastDotIndex = textBeforeCursor.lastIndexOf(".");
      let methodSuggestions = [];
      let isDotAfterVariable = false;
      if (lastDotIndex !== -1) {
        const varName = textBeforeCursor.substring(0, lastDotIndex).trim();
        if (variables.has(varName)) {
          const varInfo = variables.get(varName);
          isDotAfterVariable = true;
          switch (varInfo?.type) {
            case "ArrayList":
              methodSuggestions = getArrayListSuggestions(monaco, range);
              break;
            case "HashMap":
              methodSuggestions = getHashMapSuggestions(monaco, range);
              break;
            case "List":
              methodSuggestions = getListSuggestions(monaco, range);
              break;
            case "Set":
              methodSuggestions = getSetSuggestions(monaco, range);
              break;
            case "Queue":
              methodSuggestions = getQueueSuggestions2(monaco, range);
              break;
            case "Stack":
              methodSuggestions = getStackSuggestions2(monaco, range);
              break;
            case "Deque":
              methodSuggestions = getDequeSuggestions2(monaco, range);
              break;
            default:
              break;
          }
        }
      }
      if (!isDotAfterVariable) {
        const generalSuggestions = getGeneralSuggestions2(monaco, range);
        return {
          suggestions: [...generalSuggestions, ...variableSuggestions]
        };
      } else {
        return {
          suggestions: [...methodSuggestions]
        };
      }
    }
  });
}

// src/index.ts
function waitForMonaco() {
  return new Promise((resolve) => {
    const interval = setInterval(() => {
      if (window.monaco) {
        clearInterval(interval);
        resolve(window.monaco);
      }
    }, 100);
  });
}
async function init() {
  const monaco = await waitForMonaco();
  monaco.editor.onDidCreateEditor((editor) => {
    setTimeout(() => {
      editor.updateOptions({ suggestOnTriggerCharacters: true });
      editor.updateOptions({ quickSuggestions: { comments: "on", strings: "on", other: "on" } });
    }, 500);
  });
  initCppCompletion(monaco);
  initJavaCompletion(monaco);
}
window.addEventListener("load", init);