☰

Greasy Fork is available in English.

LeetCode Intelligent

为 LeetCode 增加智能代码提示，提供代码补全功能

  1. // ==UserScript==
  2. // @name         LeetCode Intelligent
  3. // @namespace    https://shiyu.dev/
  4. // @version      0.1
  5. // @description  为 LeetCode 增加智能代码提示，提供代码补全功能
  6. // @author       ShiYu
  7. // @license      MIT
  8. // @match        https://leetcode.com/problems/* 
  9. // @match        https://leetcode.cn/problems/*
  10. // @match        https://www.leetcode.com/problems/* 
  11. // @match        https://www.leetcode.cn/problems/*
  12. // @grant        none
  13. // @antifeature  none
  14. // @run-at       document-end
  15. // ==/UserScript==
  16.  
  17. // src/cpp/utils.ts
  18. function extractVariables(code, position) {
  19.   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;
  20.   const basicTypeRegex = /\b(?:int|float|double|char|bool|string|auto)\s+(\w+)\s*;/g;
  21.   const funcParamRegex = /\(([^)]*)\)/g;
  22.   const variables = new Map;
  23.   const lines = code.split("\n").slice(0, position.lineNumber - 1);
  24.   let currentLine = code.split("\n")[position.lineNumber - 1].substring(0, position.column - 1);
  25.   lines.push(currentLine);
  26.   const codeBeforeCursor = lines.join("\n");
  27.   let match;
  28.   while ((match = variableRegex.exec(codeBeforeCursor)) !== null) {
  29.     const varName = match[1];
  30.     variables.set(varName, { type: "template", kind: "variable" });
  31.   }
  32.   while ((match = basicTypeRegex.exec(codeBeforeCursor)) !== null) {
  33.     const varName = match[1];
  34.     variables.set(varName, { type: "basic", kind: "variable" });
  35.   }
  36.   const funcMatch = funcParamRegex.exec(codeBeforeCursor);
  37.   if (funcMatch) {
  38.     const params = funcMatch[1].split(",");
  39.     params.forEach((param) => {
  40.       const parts = param.trim().split(/\s+/);
  41.       const paramName = parts[parts.length - 1];
  42.       variables.set(paramName, { type: "parameter", kind: "parameter" });
  43.     });
  44.   }
  45.   return variables;
  46. }
  47. function getRange(position, word) {
  48.   return {
  49.     startLineNumber: position.lineNumber,
  50.     endLineNumber: position.lineNumber,
  51.     startColumn: word.startColumn,
  52.     endColumn: word.endColumn
  53.   };
  54. }
  55.  
  56. // src/cpp/vector.ts
  57. function getVectorSuggestions(monaco, range) {
  58.   return [
  59.     {
  60.       label: "push_back",
  61.       kind: monaco.languages.CompletionItemKind.Method,
  62.       insertText: "push_back(${1:value});",
  63.       insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
  64.       documentation: "Adds an element to the end of the vector.",
  65.       range
  66.     },
  67.     {
  68.       label: "pop_back",
  69.       kind: monaco.languages.CompletionItemKind.Method,
  70.       insertText: "pop_back();",
  71.       documentation: "Removes the last element of the vector.",
  72.       range
  73.     },
  74.     {
  75.       label: "size",
  76.       kind: monaco.languages.CompletionItemKind.Method,
  77.       insertText: "size()",
  78.       documentation: "Returns the number of elements in the vector.",
  79.       range
  80.     },
  81.     {
  82.       label: "clear",
  83.       kind: monaco.languages.CompletionItemKind.Method,
  84.       insertText: "clear();",
  85.       documentation: "Removes all elements from the vector.",
  86.       range
  87.     },
  88.     {
  89.       label: "at",
  90.       kind: monaco.languages.CompletionItemKind.Method,
  91.       insertText: "at(${1:index})",
  92.       insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
  93.       documentation: "Returns a reference to the element at the specified position.",
  94.       range
  95.     },
  96.     {
  97.       label: "empty",
  98.       kind: monaco.languages.CompletionItemKind.Method,
  99.       insertText: "empty()",
  100.       documentation: "Checks if the vector is empty.",
  101.       range
  102.     },
  103.     {
  104.       label: "reserve",
  105.       kind: monaco.languages.CompletionItemKind.Method,
  106.       insertText: "reserve(${1:size});",
  107.       insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
  108.       documentation: "Requests that the vector capacity be at least enough to contain a specified number of elements.",
  109.       range
  110.     },
  111.     {
  112.       label: "capacity",
  113.       kind: monaco.languages.CompletionItemKind.Method,
  114.       insertText: "capacity()",
  115.       documentation: "Returns the number of elements that can be held in currently allocated storage.",
  116.       range
  117.     },
  118.     {
  119.       label: "front",
  120.       kind: monaco.languages.CompletionItemKind.Method,
  121.       insertText: "front()",
  122.       documentation: "Returns a reference to the first element in the vector.",
  123.       range
  124.     },
  125.     {
  126.       label: "back",
  127.       kind: monaco.languages.CompletionItemKind.Method,
  128.       insertText: "back()",
  129.       documentation: "Returns a reference to the last element in the vector.",
  130.       range
  131.     },
  132.     {
  133.       label: "insert",
  134.       kind: monaco.languages.CompletionItemKind.Method,
  135.       insertText: "insert(${1:position}, ${2:value});",
  136.       insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
  137.       documentation: "Inserts elements at the specified position.",
  138.       range
  139.     },
  140.     {
  141.       label: "erase",
  142.       kind: monaco.languages.CompletionItemKind.Method,
  143.       insertText: "erase(${1:position});",
  144.       insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
  145.       documentation: "Erases elements at the specified position.",
  146.       range
  147.     },
  148.     {
  149.       label: "resize",
  150.       kind: monaco.languages.CompletionItemKind.Method,
  151.       insertText: "resize(${1:new_size});",
  152.       insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
  153.       documentation: "Resizes the container to contain the specified number of elements.",
  154.       range
  155.     },
  156.     {
  157.       label: "shrink_to_fit",
  158.       kind: monaco.languages.CompletionItemKind.Method,
  159.       insertText: "shrink_to_fit();",
  160.       documentation: "Reduces the capacity of the vector to fit its size.",
  161.       range
  162.     },
  163.     {
  164.       label: "data",
  165.       kind: monaco.languages.CompletionItemKind.Method,
  166.       insertText: "data()",
  167.       documentation: "Returns a direct pointer to the memory array used internally by the vector to store its owned elements.",
  168.       range
  169.     },
  170.     {
  171.       label: "emplace_back",
  172.       kind: monaco.languages.CompletionItemKind.Method,
  173.       insertText: "emplace_back(${1:args});",
  174.       insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
  175.       documentation: "Constructs and inserts a new element at the end of the vector.",
  176.       range
  177.     }
  178.   ];
  179. }
  180.  
  181. // src/cpp/stack.ts
  182. function getStackSuggestions(monaco, range) {
  183.   return [
  184.     {
  185.       label: "push",
  186.       kind: monaco.languages.CompletionItemKind.Method,
  187.       insertText: "push(${1:value});",
  188.       insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
  189.       documentation: "Pushes an element onto the stack.",
  190.       range
  191.     },
  192.     {
  193.       label: "pop",
  194.       kind: monaco.languages.CompletionItemKind.Method,
  195.       insertText: "pop();",
  196.       documentation: "Removes the top element of the stack.",
  197.       range
  198.     },
  199.     {
  200.       label: "top",
  201.       kind: monaco.languages.CompletionItemKind.Method,
  202.       insertText: "top()",
  203.       documentation: "Returns a reference to the top element of the stack.",
  204.       range
  205.     },
  206.     {
  207.       label: "empty",
  208.       kind: monaco.languages.CompletionItemKind.Method,
  209.       insertText: "empty()",
  210.       documentation: "Checks whether the stack is empty.",
  211.       range
  212.     },
  213.     {
  214.       label: "size",
  215.       kind: monaco.languages.CompletionItemKind.Method,
  216.       insertText: "size()",
  217.       documentation: "Returns the number of elements in the stack.",
  218.       range
  219.     },
  220.     {
  221.       label: "emplace",
  222.       kind: monaco.languages.CompletionItemKind.Method,
  223.       insertText: "emplace(${1:args});",
  224.       insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
  225.       documentation: "Constructs and inserts an element at the top of the stack.",
  226.       range
  227.     },
  228.     {
  229.       label: "swap",
  230.       kind: monaco.languages.CompletionItemKind.Method,
  231.       insertText: "swap(${1:other_stack});",
  232.       insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
  233.       documentation: "Exchanges the contents of the container with another stack.",
  234.       range
  235.     }
  236.   ];
  237. }
  238.  
  239. // src/cpp/queue.ts
  240. function getQueueSuggestions(monaco, range) {
  241.   return [
  242.     {
  243.       label: "push",
  244.       kind: monaco.languages.CompletionItemKind.Method,
  245.       insertText: "push(${1:value});",
  246.       insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
  247.       documentation: "Inserts an element at the end of the queue.",
  248.       range
  249.     },
  250.     {
  251.       label: "pop",
  252.       kind: monaco.languages.CompletionItemKind.Method,
  253.       insertText: "pop();",
  254.       documentation: "Removes the next element in the queue.",
  255.       range
  256.     },
  257.     {
  258.       label: "front",
  259.       kind: monaco.languages.CompletionItemKind.Method,
  260.       insertText: "front()",
  261.       documentation: "Accesses the next element in the queue.",
  262.       range
  263.     },
  264.     {
  265.       label: "back",
  266.       kind: monaco.languages.CompletionItemKind.Method,
  267.       insertText: "back()",
  268.       documentation: "Accesses the last element in the queue.",
  269.       range
  270.     },
  271.     {
  272.       label: "empty",
  273.       kind: monaco.languages.CompletionItemKind.Method,
  274.       insertText: "empty()",
  275.       documentation: "Checks if the queue is empty.",
  276.       range
  277.     },
  278.     {
  279.       label: "size",
  280.       kind: monaco.languages.CompletionItemKind.Method,
  281.       insertText: "size()",
  282.       documentation: "Returns the number of elements in the queue.",
  283.       range
  284.     },
  285.     {
  286.       label: "emplace",
  287.       kind: monaco.languages.CompletionItemKind.Method,
  288.       insertText: "emplace(${1:args});",
  289.       insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
  290.       documentation: "Constructs and inserts a new element at the end of the queue.",
  291.       range
  292.     },
  293.     {
  294.       label: "swap",
  295.       kind: monaco.languages.CompletionItemKind.Method,
  296.       insertText: "swap(${1:other_queue});",
  297.       insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
  298.       documentation: "Exchanges the contents of the queue with another.",
  299.       range
  300.     }
  301.   ];
  302. }
  303.  
  304. // src/cpp/generalSuggestions.ts
  305. function getGeneralSuggestions(monaco, range) {
  306.   return [
  307.     {
  308.       label: "cout",
  309.       kind: monaco.languages.CompletionItemKind.Snippet,
  310.       insertText: "cout << $1 << endl;",
  311.       insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
  312.       documentation: "Standard output stream",
  313.       range
  314.     },
  315.     {
  316.       label: "cin",
  317.       kind: monaco.languages.CompletionItemKind.Snippet,
  318.       insertText: "cin >> $1;",
  319.       insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
  320.       documentation: "Standard input stream",
  321.       range
  322.     },
  323.     {
  324.       label: "for (auto x : num)",
  325.       kind: monaco.languages.CompletionItemKind.Snippet,
  326.       insertText: "for (auto ${1:x} : ${2:container}) {\n\t$0\n}",
  327.       insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
  328.       documentation: "Range-based for loop using auto",
  329.       range
  330.     },
  331.     {
  332.       label: "for",
  333.       kind: monaco.languages.CompletionItemKind.Snippet,
  334.       insertText: "for (int ${1:i} = 0; ${1:i} < ${2:n}; ${1:i}++) {\n\t$0\n}",
  335.       insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
  336.       documentation: "For loop",
  337.       range
  338.     },
  339.     {
  340.       label: "while",
  341.       kind: monaco.languages.CompletionItemKind.Snippet,
  342.       insertText: "while (${1:condition}) {\n\t$0\n}",
  343.       insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
  344.       documentation: "While loop",
  345.       range
  346.     },
  347.     {
  348.       label: "vector",
  349.       kind: monaco.languages.CompletionItemKind.Snippet,
  350.       insertText: "vector<${1:int}> ${2:vec};",
  351.       insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
  352.       documentation: "Creates a std::vector",
  353.       range
  354.     },
  355.     {
  356.       label: "stack",
  357.       kind: monaco.languages.CompletionItemKind.Snippet,
  358.       insertText: "stack<${1:int}> ${2:stk};",
  359.       insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
  360.       documentation: "Creates a std::stack",
  361.       range
  362.     },
  363.     {
  364.       label: "queue",
  365.       kind: monaco.languages.CompletionItemKind.Snippet,
  366.       insertText: "queue<${1:int}> ${2:q};",
  367.       insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
  368.       documentation: "Creates a std::queue",
  369.       range
  370.     },
  371.     {
  372.       label: "deque",
  373.       kind: monaco.languages.CompletionItemKind.Snippet,
  374.       insertText: "deque<${1:int}> ${2:dq};",
  375.       insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
  376.       documentation: "Creates a std::deque",
  377.       range
  378.     },
  379.     {
  380.       label: "map",
  381.       kind: monaco.languages.CompletionItemKind.Snippet,
  382.       insertText: "map<${1:int}, ${2:int}> ${3:m};",
  383.       insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
  384.       documentation: "Creates a std::map",
  385.       range
  386.     },
  387.     {
  388.       label: "unordered_map",
  389.       kind: monaco.languages.CompletionItemKind.Snippet,
  390.       insertText: "unordered_map<${1:int}, ${2:int}> ${3:umap};",
  391.       insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
  392.       documentation: "Creates a std::unordered_map",
  393.       range
  394.     },
  395.     {
  396.       label: "set",
  397.       kind: monaco.languages.CompletionItemKind.Snippet,
  398.       insertText: "set<${1:int}> ${2:s};",
  399.       insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
  400.       documentation: "Creates a std::set",
  401.       range
  402.     },
  403.     {
  404.       label: "unordered_set",
  405.       kind: monaco.languages.CompletionItemKind.Snippet,
  406.       insertText: "unordered_set<${1:int}> ${2:uset};",
  407.       insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
  408.       documentation: "Creates a std::unordered_set",
  409.       range
  410.     },
  411.     {
  412.       label: "multimap",
  413.       kind: monaco.languages.CompletionItemKind.Snippet,
  414.       insertText: "multimap<${1:int}, ${2:int}> ${3:mm};",
  415.       insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
  416.       documentation: "Creates a std::multimap",
  417.       range
  418.     },
  419.     {
  420.       label: "multiset",
  421.       kind: monaco.languages.CompletionItemKind.Snippet,
  422.       insertText: "multiset<${1:int}> ${2:ms};",
  423.       insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
  424.       documentation: "Creates a std::multiset",
  425.       range
  426.     },
  427.     {
  428.       label: "priority_queue",
  429.       kind: monaco.languages.CompletionItemKind.Snippet,
  430.       insertText: "priority_queue<${1:int}> ${2:pq};",
  431.       insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
  432.       documentation: "Creates a std::priority_queue",
  433.       range
  434.     },
  435.     {
  436.       label: "array",
  437.       kind: monaco.languages.CompletionItemKind.Snippet,
  438.       insertText: "array<${1:int}, ${2:N}> ${3:arr};",
  439.       insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
  440.       documentation: "Creates a std::array",
  441.       range
  442.     },
  443.     {
  444.       label: "pair",
  445.       kind: monaco.languages.CompletionItemKind.Snippet,
  446.       insertText: "pair<${1:int}, ${2:int}> ${3:p};",
  447.       insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
  448.       documentation: "Creates a std::pair",
  449.       range
  450.     },
  451.     {
  452.       label: "forward_list",
  453.       kind: monaco.languages.CompletionItemKind.Snippet,
  454.       insertText: "forward_list<${1:int}> ${2:fl};",
  455.       insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
  456.       documentation: "Creates a std::forward_list",
  457.       range
  458.     },
  459.     {
  460.       label: "unordered_multimap",
  461.       kind: monaco.languages.CompletionItemKind.Snippet,
  462.       insertText: "unordered_multimap<${1:int}, ${2:int}> ${3:umm};",
  463.       insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
  464.       documentation: "Creates a std::unordered_multimap",
  465.       range
  466.     },
  467.     {
  468.       label: "unordered_multiset",
  469.       kind: monaco.languages.CompletionItemKind.Snippet,
  470.       insertText: "unordered_multiset<${1:int}> ${2:ums};",
  471.       insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
  472.       documentation: "Creates a std::unordered_multiset",
  473.       range
  474.     },
  475.     {
  476.       label: "tuple",
  477.       kind: monaco.languages.CompletionItemKind.Snippet,
  478.       insertText: "tuple<${1:int}, ${2:int}, ${3:int}> ${4:tup};",
  479.       insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
  480.       documentation: "Creates a std::tuple",
  481.       range
  482.     },
  483.     {
  484.       label: "sort",
  485.       kind: monaco.languages.CompletionItemKind.Function,
  486.       insertText: "sort(${1:begin}, ${2:end});",
  487.       insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
  488.       documentation: "Sorts the range [begin, end).",
  489.       range
  490.     },
  491.     {
  492.       label: "max",
  493.       kind: monaco.languages.CompletionItemKind.Function,
  494.       insertText: "max(${1:a}, ${2:b});",
  495.       insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
  496.       documentation: "Returns the maximum of two values.",
  497.       range
  498.     },
  499.     {
  500.       label: "min",
  501.       kind: monaco.languages.CompletionItemKind.Function,
  502.       insertText: "min(${1:a}, ${2:b});",
  503.       insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
  504.       documentation: "Returns the minimum of two values.",
  505.       range
  506.     },
  507.     {
  508.       label: "reverse",
  509.       kind: monaco.languages.CompletionItemKind.Function,
  510.       insertText: "reverse(${1:begin}, ${2:end});",
  511.       insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
  512.       documentation: "Reverses the range [begin, end).",
  513.       range
  514.     },
  515.     {
  516.       label: "find",
  517.       kind: monaco.languages.CompletionItemKind.Function,
  518.       insertText: "find(${1:begin}, ${2:end}, ${3:value});",
  519.       insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
  520.       documentation: "Finds the first occurrence of value in the range [begin, end).",
  521.       range
  522.     },
  523.     {
  524.       label: "accumulate",
  525.       kind: monaco.languages.CompletionItemKind.Function,
  526.       insertText: "accumulate(${1:begin}, ${2:end}, ${3:init});",
  527.       insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
  528.       documentation: "Accumulates the sum of the range [begin, end) starting from init.",
  529.       range
  530.     },
  531.     {
  532.       label: "binary_search",
  533.       kind: monaco.languages.CompletionItemKind.Function,
  534.       insertText: "binary_search(${1:begin}, ${2:end}, ${3:value});",
  535.       insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
  536.       documentation: "Checks if value exists in the sorted range [begin, end).",
  537.       range
  538.     },
  539.     {
  540.       label: "lower_bound",
  541.       kind: monaco.languages.CompletionItemKind.Function,
  542.       insertText: "lower_bound(${1:begin}, ${2:end}, ${3:value});",
  543.       insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
  544.       documentation: "Returns an iterator pointing to the first element not less than value in the sorted range [begin, end).",
  545.       range
  546.     },
  547.     {
  548.       label: "upper_bound",
  549.       kind: monaco.languages.CompletionItemKind.Function,
  550.       insertText: "upper_bound(${1:begin}, ${2:end}, ${3:value});",
  551.       insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
  552.       documentation: "Returns an iterator pointing to the first element greater than value in the sorted range [begin, end).",
  553.       range
  554.     },
  555.     {
  556.       label: "unique",
  557.       kind: monaco.languages.CompletionItemKind.Function,
  558.       insertText: "unique(${1:begin}, ${2:end});",
  559.       insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
  560.       documentation: "Removes consecutive duplicates in the range [begin, end).",
  561.       range
  562.     }
  563.   ];
  564. }
  565.  
  566. // src/cpp/deque.ts
  567. function getDequeSuggestions(monaco, range) {
  568.   return [
  569.     {
  570.       label: "push_back",
  571.       kind: monaco.languages.CompletionItemKind.Method,
  572.       insertText: "push_back(${1:value});",
  573.       insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
  574.       documentation: "Adds an element to the end of the deque.",
  575.       range
  576.     },
  577.     {
  578.       label: "push_front",
  579.       kind: monaco.languages.CompletionItemKind.Method,
  580.       insertText: "push_front(${1:value});",
  581.       insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
  582.       documentation: "Adds an element to the front of the deque.",
  583.       range
  584.     },
  585.     {
  586.       label: "pop_back",
  587.       kind: monaco.languages.CompletionItemKind.Method,
  588.       insertText: "pop_back();",
  589.       documentation: "Removes the last element of the deque.",
  590.       range
  591.     },
  592.     {
  593.       label: "pop_front",
  594.       kind: monaco.languages.CompletionItemKind.Method,
  595.       insertText: "pop_front();",
  596.       documentation: "Removes the first element of the deque.",
  597.       range
  598.     },
  599.     {
  600.       label: "size",
  601.       kind: monaco.languages.CompletionItemKind.Method,
  602.       insertText: "size()",
  603.       documentation: "Returns the number of elements in the deque.",
  604.       range
  605.     },
  606.     {
  607.       label: "clear",
  608.       kind: monaco.languages.CompletionItemKind.Method,
  609.       insertText: "clear();",
  610.       documentation: "Removes all elements from the deque.",
  611.       range
  612.     },
  613.     {
  614.       label: "at",
  615.       kind: monaco.languages.CompletionItemKind.Method,
  616.       insertText: "at(${1:index})",
  617.       insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
  618.       documentation: "Returns a reference to the element at the specified position.",
  619.       range
  620.     },
  621.     {
  622.       label: "empty",
  623.       kind: monaco.languages.CompletionItemKind.Method,
  624.       insertText: "empty()",
  625.       documentation: "Checks if the deque is empty.",
  626.       range
  627.     },
  628.     {
  629.       label: "front",
  630.       kind: monaco.languages.CompletionItemKind.Method,
  631.       insertText: "front()",
  632.       documentation: "Returns a reference to the first element in the deque.",
  633.       range
  634.     },
  635.     {
  636.       label: "back",
  637.       kind: monaco.languages.CompletionItemKind.Method,
  638.       insertText: "back()",
  639.       documentation: "Returns a reference to the last element in the deque.",
  640.       range
  641.     },
  642.     {
  643.       label: "insert",
  644.       kind: monaco.languages.CompletionItemKind.Method,
  645.       insertText: "insert(${1:position}, ${2:value});",
  646.       insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
  647.       documentation: "Inserts elements at the specified position.",
  648.       range
  649.     },
  650.     {
  651.       label: "erase",
  652.       kind: monaco.languages.CompletionItemKind.Method,
  653.       insertText: "erase(${1:position});",
  654.       insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
  655.       documentation: "Erases elements at the specified position.",
  656.       range
  657.     },
  658.     {
  659.       label: "resize",
  660.       kind: monaco.languages.CompletionItemKind.Method,
  661.       insertText: "resize(${1:new_size});",
  662.       insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
  663.       documentation: "Resizes the container to contain the specified number of elements.",
  664.       range
  665.     },
  666.     {
  667.       label: "shrink_to_fit",
  668.       kind: monaco.languages.CompletionItemKind.Method,
  669.       insertText: "shrink_to_fit();",
  670.       documentation: "Reduces the capacity of the deque to fit its size.",
  671.       range
  672.     },
  673.     {
  674.       label: "data",
  675.       kind: monaco.languages.CompletionItemKind.Method,
  676.       insertText: "data()",
  677.       documentation: "Returns a direct pointer to the memory array used internally by the deque.",
  678.       range
  679.     }
  680.   ];
  681. }
  682.  
  683. // src/cpp/map.ts
  684. function getMapSuggestions(monaco, range) {
  685.   return [
  686.     {
  687.       label: "insert",
  688.       kind: monaco.languages.CompletionItemKind.Method,
  689.       insertText: "insert(${1:pair});",
  690.       insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
  691.       documentation: "Inserts a pair (key, value) into the map.",
  692.       range
  693.     },
  694.     {
  695.       label: "erase",
  696.       kind: monaco.languages.CompletionItemKind.Method,
  697.       insertText: "erase(${1:key});",
  698.       insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
  699.       documentation: "Erases the element by key from the map.",
  700.       range
  701.     },
  702.     {
  703.       label: "find",
  704.       kind: monaco.languages.CompletionItemKind.Method,
  705.       insertText: "find(${1:key})",
  706.       insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
  707.       documentation: "Finds an element by its key.",
  708.       range
  709.     },
  710.     {
  711.       label: "size",
  712.       kind: monaco.languages.CompletionItemKind.Method,
  713.       insertText: "size()",
  714.       documentation: "Returns the number of elements in the map.",
  715.       range
  716.     },
  717.     {
  718.       label: "clear",
  719.       kind: monaco.languages.CompletionItemKind.Method,
  720.       insertText: "clear();",
  721.       documentation: "Removes all elements from the map.",
  722.       range
  723.     },
  724.     {
  725.       label: "empty",
  726.       kind: monaco.languages.CompletionItemKind.Method,
  727.       insertText: "empty()",
  728.       documentation: "Checks if the map is empty.",
  729.       range
  730.     },
  731.     {
  732.       label: "at",
  733.       kind: monaco.languages.CompletionItemKind.Method,
  734.       insertText: "at(${1:key})",
  735.       insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
  736.       documentation: "Accesses an element by key and returns a reference to its value.",
  737.       range
  738.     },
  739.     {
  740.       label: "count",
  741.       kind: monaco.languages.CompletionItemKind.Method,
  742.       insertText: "count(${1:key})",
  743.       documentation: "Returns the number of elements matching the key (either 0 or 1 in a map).",
  744.       range
  745.     }
  746.   ];
  747. }
  748.  
  749. // src/cpp/unordered_map.ts
  750. function getUnorderedMapSuggestions(monaco, range) {
  751.   return [
  752.     {
  753.       label: "insert",
  754.       kind: monaco.languages.CompletionItemKind.Method,
  755.       insertText: "insert(${1:pair});",
  756.       insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
  757.       documentation: "Inserts a pair (key, value) into the unordered_map.",
  758.       range
  759.     },
  760.     {
  761.       label: "erase",
  762.       kind: monaco.languages.CompletionItemKind.Method,
  763.       insertText: "erase(${1:key});",
  764.       insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
  765.       documentation: "Erases the element by key from the unordered_map.",
  766.       range
  767.     },
  768.     {
  769.       label: "find",
  770.       kind: monaco.languages.CompletionItemKind.Method,
  771.       insertText: "find(${1:key})",
  772.       insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
  773.       documentation: "Finds an element by its key.",
  774.       range
  775.     },
  776.     {
  777.       label: "size",
  778.       kind: monaco.languages.CompletionItemKind.Method,
  779.       insertText: "size()",
  780.       documentation: "Returns the number of elements in the unordered_map.",
  781.       range
  782.     },
  783.     {
  784.       label: "clear",
  785.       kind: monaco.languages.CompletionItemKind.Method,
  786.       insertText: "clear();",
  787.       documentation: "Removes all elements from the unordered_map.",
  788.       range
  789.     },
  790.     {
  791.       label: "empty",
  792.       kind: monaco.languages.CompletionItemKind.Method,
  793.       insertText: "empty()",
  794.       documentation: "Checks if the unordered_map is empty.",
  795.       range
  796.     },
  797.     {
  798.       label: "at",
  799.       kind: monaco.languages.CompletionItemKind.Method,
  800.       insertText: "at(${1:key})",
  801.       insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
  802.       documentation: "Accesses an element by key and returns a reference to its value.",
  803.       range
  804.     },
  805.     {
  806.       label: "count",
  807.       kind: monaco.languages.CompletionItemKind.Method,
  808.       insertText: "count(${1:key})",
  809.       documentation: "Returns the number of elements matching the key (either 0 or 1 in an unordered_map).",
  810.       range
  811.     }
  812.   ];
  813. }
  814.  
  815. // src/cpp/index.ts
  816. function initCppCompletion(monaco) {
  817.   monaco.languages.registerCompletionItemProvider("cpp", {
  818.     provideCompletionItems: (model, position) => {
  819.       const word = model.getWordUntilPosition(position);
  820.       const range = getRange(position, word);
  821.       const code = model.getValue();
  822.       const variables = extractVariables(code, position);
  823.       const variableSuggestions = [];
  824.       variables.forEach(({ type }, name) => {
  825.         variableSuggestions.push({
  826.           label: name,
  827.           kind: monaco.languages.CompletionItemKind.Variable,
  828.           insertText: name,
  829.           documentation: `Variable of type ${type}`,
  830.           range
  831.         });
  832.       });
  833.       const lineContent = model.getLineContent(position.lineNumber);
  834.       const textBeforeCursor = lineContent.substring(0, position.column - 1).trim();
  835.       const lastDotIndex = textBeforeCursor.lastIndexOf(".");
  836.       let functionSuggestions = [];
  837.       let isDotAfterVariable = false;
  838.       if (lastDotIndex !== -1) {
  839.         const varName = textBeforeCursor.substring(0, lastDotIndex).trim();
  840.         if (variables.has(varName)) {
  841.           const varInfo = variables.get(varName);
  842.           isDotAfterVariable = true;
  843.           switch (varInfo?.type) {
  844.             case "template":
  845.               functionSuggestions = getVectorSuggestions(monaco, range);
  846.               break;
  847.             case "stack":
  848.               functionSuggestions = getStackSuggestions(monaco, range);
  849.               break;
  850.             case "queue":
  851.               functionSuggestions = getQueueSuggestions(monaco, range);
  852.               break;
  853.             case "deque":
  854.               functionSuggestions = getDequeSuggestions(monaco, range);
  855.               break;
  856.             case "map":
  857.               functionSuggestions = getMapSuggestions(monaco, range);
  858.               break;
  859.             case "unordered_map":
  860.               functionSuggestions = getUnorderedMapSuggestions(monaco, range);
  861.               break;
  862.             default:
  863.               break;
  864.           }
  865.         }
  866.       }
  867.       if (!isDotAfterVariable) {
  868.         const generalSuggestions = getGeneralSuggestions(monaco, range);
  869.         return {
  870.           suggestions: [...generalSuggestions, ...variableSuggestions]
  871.         };
  872.       } else {
  873.         return {
  874.           suggestions: [...functionSuggestions]
  875.         };
  876.       }
  877.     }
  878.   });
  879. }
  880.  
  881. // src/java/arrayList.ts
  882. function getArrayListSuggestions(monaco, range) {
  883.   return [
  884.     {
  885.       label: "add",
  886.       kind: monaco.languages.CompletionItemKind.Method,
  887.       insertText: "add(${1:element});",
  888.       insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
  889.       documentation: "Adds an element to the ArrayList.",
  890.       range
  891.     },
  892.     {
  893.       label: "remove",
  894.       kind: monaco.languages.CompletionItemKind.Method,
  895.       insertText: "remove(${1:index});",
  896.       documentation: "Removes the element at the specified index.",
  897.       range
  898.     },
  899.     {
  900.       label: "get",
  901.       kind: monaco.languages.CompletionItemKind.Method,
  902.       insertText: "get(${1:index});",
  903.       documentation: "Returns the element at the specified index.",
  904.       range
  905.     },
  906.     {
  907.       label: "set",
  908.       kind: monaco.languages.CompletionItemKind.Method,
  909.       insertText: "set(${1:index}, ${2:element});",
  910.       insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
  911.       documentation: "Replaces the element at the specified index with the specified element.",
  912.       range
  913.     },
  914.     {
  915.       label: "size",
  916.       kind: monaco.languages.CompletionItemKind.Method,
  917.       insertText: "size();",
  918.       documentation: "Returns the number of elements in the ArrayList.",
  919.       range
  920.     },
  921.     {
  922.       label: "clear",
  923.       kind: monaco.languages.CompletionItemKind.Method,
  924.       insertText: "clear();",
  925.       documentation: "Removes all elements from the ArrayList.",
  926.       range
  927.     },
  928.     {
  929.       label: "contains",
  930.       kind: monaco.languages.CompletionItemKind.Method,
  931.       insertText: "contains(${1:element});",
  932.       insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
  933.       documentation: "Returns true if this list contains the specified element.",
  934.       range
  935.     },
  936.     {
  937.       label: "indexOf",
  938.       kind: monaco.languages.CompletionItemKind.Method,
  939.       insertText: "indexOf(${1:element});",
  940.       insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
  941.       documentation: "Returns the index of the first occurrence of the specified element, or -1 if this list does not contain the element.",
  942.       range
  943.     },
  944.     {
  945.       label: "lastIndexOf",
  946.       kind: monaco.languages.CompletionItemKind.Method,
  947.       insertText: "lastIndexOf(${1:element});",
  948.       insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
  949.       documentation: "Returns the index of the last occurrence of the specified element, or -1 if this list does not contain the element.",
  950.       range
  951.     },
  952.     {
  953.       label: "isEmpty",
  954.       kind: monaco.languages.CompletionItemKind.Method,
  955.       insertText: "isEmpty();",
  956.       documentation: "Returns true if this list contains no elements.",
  957.       range
  958.     },
  959.     {
  960.       label: "toArray",
  961.       kind: monaco.languages.CompletionItemKind.Method,
  962.       insertText: "toArray();",
  963.       documentation: "Returns an array containing all of the elements in this list in proper sequence.",
  964.       range
  965.     }
  966.   ];
  967. }
  968.  
  969. // src/java/hashMap.ts
  970. function getHashMapSuggestions(monaco, range) {
  971.   return [
  972.     {
  973.       label: "put",
  974.       kind: monaco.languages.CompletionItemKind.Method,
  975.       insertText: "put(${1:key}, ${2:value});",
  976.       insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
  977.       documentation: "Associates the specified value with the specified key in this map.",
  978.       range
  979.     },
  980.     {
  981.       label: "get",
  982.       kind: monaco.languages.CompletionItemKind.Method,
  983.       insertText: "get(${1:key});",
  984.       documentation: "Returns the value to which the specified key is mapped, or null if this map contains no mapping for the key.",
  985.       range
  986.     },
  987.     {
  988.       label: "remove",
  989.       kind: monaco.languages.CompletionItemKind.Method,
  990.       insertText: "remove(${1:key});",
  991.       documentation: "Removes the mapping for the specified key from this map if present.",
  992.       range
  993.     },
  994.     {
  995.       label: "containsKey",
  996.       kind: monaco.languages.CompletionItemKind.Method,
  997.       insertText: "containsKey(${1:key});",
  998.       documentation: "Returns true if this map contains a mapping for the specified key.",
  999.       range
  1000.     },
  1001.     {
  1002.       label: "containsValue",
  1003.       kind: monaco.languages.CompletionItemKind.Method,
  1004.       insertText: "containsValue(${1:value});",
  1005.       insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
  1006.       documentation: "Returns true if this map maps one or more keys to the specified value.",
  1007.       range
  1008.     },
  1009.     {
  1010.       label: "keySet",
  1011.       kind: monaco.languages.CompletionItemKind.Method,
  1012.       insertText: "keySet();",
  1013.       documentation: "Returns a Set view of the keys contained in this map.",
  1014.       range
  1015.     },
  1016.     {
  1017.       label: "size",
  1018.       kind: monaco.languages.CompletionItemKind.Method,
  1019.       insertText: "size();",
  1020.       documentation: "Returns the number of key-value mappings in this map.",
  1021.       range
  1022.     },
  1023.     {
  1024.       label: "clear",
  1025.       kind: monaco.languages.CompletionItemKind.Method,
  1026.       insertText: "clear();",
  1027.       documentation: "Removes all of the mappings from this map. The map will be empty after this call.",
  1028.       range
  1029.     },
  1030.     {
  1031.       label: "values",
  1032.       kind: monaco.languages.CompletionItemKind.Method,
  1033.       insertText: "values();",
  1034.       documentation: "Returns a Collection view of the values contained in this map.",
  1035.       range
  1036.     },
  1037.     {
  1038.       label: "entrySet",
  1039.       kind: monaco.languages.CompletionItemKind.Method,
  1040.       insertText: "entrySet();",
  1041.       documentation: "Returns a Set view of the mappings contained in this map.",
  1042.       range
  1043.     }
  1044.   ];
  1045. }
  1046.  
  1047. // src/java/list.ts
  1048. function getListSuggestions(monaco, range) {
  1049.   return [
  1050.     {
  1051.       label: "add",
  1052.       kind: monaco.languages.CompletionItemKind.Method,
  1053.       insertText: "add(${1:element});",
  1054.       insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
  1055.       documentation: "Appends the specified element to the end of this list.",
  1056.       range
  1057.     },
  1058.     {
  1059.       label: "get",
  1060.       kind: monaco.languages.CompletionItemKind.Method,
  1061.       insertText: "get(${1:index});",
  1062.       documentation: "Returns the element at the specified position in this list.",
  1063.       range
  1064.     },
  1065.     {
  1066.       label: "remove",
  1067.       kind: monaco.languages.CompletionItemKind.Method,
  1068.       insertText: "remove(${1:index});",
  1069.       documentation: "Removes the element at the specified position in this list.",
  1070.       range
  1071.     },
  1072.     {
  1073.       label: "size",
  1074.       kind: monaco.languages.CompletionItemKind.Method,
  1075.       insertText: "size();",
  1076.       documentation: "Returns the number of elements in this list.",
  1077.       range
  1078.     }
  1079.   ];
  1080. }
  1081.  
  1082. // src/java/set.ts
  1083. function getSetSuggestions(monaco, range) {
  1084.   return [
  1085.     {
  1086.       label: "add",
  1087.       kind: monaco.languages.CompletionItemKind.Method,
  1088.       insertText: "add(${1:element});",
  1089.       insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
  1090.       documentation: "Adds the specified element to this set if it is not already present.",
  1091.       range
  1092.     },
  1093.     {
  1094.       label: "contains",
  1095.       kind: monaco.languages.CompletionItemKind.Method,
  1096.       insertText: "contains(${1:element});",
  1097.       documentation: "Returns true if this set contains the specified element.",
  1098.       range
  1099.     },
  1100.     {
  1101.       label: "remove",
  1102.       kind: monaco.languages.CompletionItemKind.Method,
  1103.       insertText: "remove(${1:element});",
  1104.       documentation: "Removes the specified element from this set if it is present.",
  1105.       range
  1106.     },
  1107.     {
  1108.       label: "size",
  1109.       kind: monaco.languages.CompletionItemKind.Method,
  1110.       insertText: "size();",
  1111.       documentation: "Returns the number of elements in this set.",
  1112.       range
  1113.     }
  1114.   ];
  1115. }
  1116.  
  1117. // src/java/queue.ts
  1118. function getQueueSuggestions2(monaco, range) {
  1119.   return [
  1120.     {
  1121.       label: "offer",
  1122.       kind: monaco.languages.CompletionItemKind.Method,
  1123.       insertText: "offer(${1:element});",
  1124.       insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
  1125.       documentation: "Inserts the specified element into this queue.",
  1126.       range
  1127.     },
  1128.     {
  1129.       label: "poll",
  1130.       kind: monaco.languages.CompletionItemKind.Method,
  1131.       insertText: "poll();",
  1132.       documentation: "Retrieves and removes the head of this queue, or returns null if this queue is empty.",
  1133.       range
  1134.     },
  1135.     {
  1136.       label: "peek",
  1137.       kind: monaco.languages.CompletionItemKind.Method,
  1138.       insertText: "peek();",
  1139.       documentation: "Retrieves, but does not remove, the head of this queue, or returns null if this queue is empty.",
  1140.       range
  1141.     },
  1142.     {
  1143.       label: "size",
  1144.       kind: monaco.languages.CompletionItemKind.Method,
  1145.       insertText: "size();",
  1146.       documentation: "Returns the number of elements in this queue.",
  1147.       range
  1148.     }
  1149.   ];
  1150. }
  1151.  
  1152. // src/java/stack.ts
  1153. function getStackSuggestions2(monaco, range) {
  1154.   return [
  1155.     {
  1156.       label: "push",
  1157.       kind: monaco.languages.CompletionItemKind.Method,
  1158.       insertText: "push(${1:element});",
  1159.       insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
  1160.       documentation: "Pushes an item onto the top of this stack.",
  1161.       range
  1162.     },
  1163.     {
  1164.       label: "pop",
  1165.       kind: monaco.languages.CompletionItemKind.Method,
  1166.       insertText: "pop();",
  1167.       documentation: "Removes the object at the top of this stack and returns that object as the value of this function.",
  1168.       range
  1169.     },
  1170.     {
  1171.       label: "peek",
  1172.       kind: monaco.languages.CompletionItemKind.Method,
  1173.       insertText: "peek();",
  1174.       documentation: "Looks at the object at the top of this stack without removing it from the stack.",
  1175.       range
  1176.     },
  1177.     {
  1178.       label: "size",
  1179.       kind: monaco.languages.CompletionItemKind.Method,
  1180.       insertText: "size();",
  1181.       documentation: "Returns the number of elements in this stack.",
  1182.       range
  1183.     }
  1184.   ];
  1185. }
  1186.  
  1187. // src/java/deque.ts
  1188. function getDequeSuggestions2(monaco, range) {
  1189.   return [
  1190.     {
  1191.       label: "addFirst",
  1192.       kind: monaco.languages.CompletionItemKind.Method,
  1193.       insertText: "addFirst(${1:element});",
  1194.       insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
  1195.       documentation: "Inserts the specified element at the front of this deque.",
  1196.       range
  1197.     },
  1198.     {
  1199.       label: "addLast",
  1200.       kind: monaco.languages.CompletionItemKind.Method,
  1201.       insertText: "addLast(${1:element});",
  1202.       insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
  1203.       documentation: "Inserts the specified element at the end of this deque.",
  1204.       range
  1205.     },
  1206.     {
  1207.       label: "removeFirst",
  1208.       kind: monaco.languages.CompletionItemKind.Method,
  1209.       insertText: "removeFirst();",
  1210.       documentation: "Removes and returns the first element from this deque.",
  1211.       range
  1212.     },
  1213.     {
  1214.       label: "removeLast",
  1215.       kind: monaco.languages.CompletionItemKind.Method,
  1216.       insertText: "removeLast();",
  1217.       documentation: "Removes and returns the last element from this deque.",
  1218.       range
  1219.     },
  1220.     {
  1221.       label: "size",
  1222.       kind: monaco.languages.CompletionItemKind.Method,
  1223.       insertText: "size();",
  1224.       documentation: "Returns the number of elements in this deque.",
  1225.       range
  1226.     }
  1227.   ];
  1228. }
  1229.  
  1230. // src/java/utils.ts
  1231. function extractJavaVariables(code, position) {
  1232.   const variableRegex = /\b(?:ArrayList|List|Set|Map|Queue|Stack|Deque|LinkedList|HashMap|HashSet|TreeMap|TreeSet|PriorityQueue)\s*<[^>]+>\s+(\w+)\s*=/g;
  1233.   const basicTypeRegex = /\b(?:int|float|double|char|boolean|String|byte|short|long)\s+(\w+)\s*;/g;
  1234.   const funcParamRegex = /\(([^)]*)\)/g;
  1235.   const variables = new Map;
  1236.   const lines = code.split("\n").slice(0, position.lineNumber - 1);
  1237.   let currentLine = code.split("\n")[position.lineNumber - 1].substring(0, position.column - 1);
  1238.   lines.push(currentLine);
  1239.   const codeBeforeCursor = lines.join("\n");
  1240.   let match;
  1241.   while ((match = variableRegex.exec(codeBeforeCursor)) !== null) {
  1242.     const varName = match[1];
  1243.     variables.set(varName, { type: "ArrayList", kind: "variable" });
  1244.   }
  1245.   while ((match = basicTypeRegex.exec(codeBeforeCursor)) !== null) {
  1246.     const varName = match[1];
  1247.     variables.set(varName, { type: "basic", kind: "variable" });
  1248.   }
  1249.   const funcMatch = funcParamRegex.exec(codeBeforeCursor);
  1250.   if (funcMatch) {
  1251.     const params = funcMatch[1].split(",");
  1252.     params.forEach((param) => {
  1253.       const parts = param.trim().split(/\s+/);
  1254.       const paramName = parts[parts.length - 1];
  1255.       variables.set(paramName, { type: "parameter", kind: "parameter" });
  1256.     });
  1257.   }
  1258.   return variables;
  1259. }
  1260. function getJavaRange(position, word) {
  1261.   return {
  1262.     startLineNumber: position.lineNumber,
  1263.     endLineNumber: position.lineNumber,
  1264.     startColumn: word.startColumn,
  1265.     endColumn: word.endColumn
  1266.   };
  1267. }
  1268.  
  1269. // src/java/getGeneralSuggestions.ts
  1270. function getGeneralSuggestions2(monaco, range) {
  1271.   return [
  1272.     {
  1273.       label: "System.out.println",
  1274.       kind: monaco.languages.CompletionItemKind.Snippet,
  1275.       insertText: "System.out.println(${1:message});",
  1276.       insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
  1277.       documentation: "Prints a message to the standard output",
  1278.       range
  1279.     },
  1280.     {
  1281.       label: "for (int i = 0; i < n; i++)",
  1282.       kind: monaco.languages.CompletionItemKind.Snippet,
  1283.       insertText: "for (int ${1:i} = 0; ${1:i} < ${2:n}; ${1:i}++) {\n\t$0\n}",
  1284.       insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
  1285.       documentation: "Basic for loop",
  1286.       range
  1287.     },
  1288.     {
  1289.       label: "while",
  1290.       kind: monaco.languages.CompletionItemKind.Snippet,
  1291.       insertText: "while (${1:condition}) {\n\t$0\n}",
  1292.       insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
  1293.       documentation: "While loop",
  1294.       range
  1295.     },
  1296.     {
  1297.       label: "if",
  1298.       kind: monaco.languages.CompletionItemKind.Snippet,
  1299.       insertText: "if (${1:condition}) {\n\t$0\n}",
  1300.       insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
  1301.       documentation: "If statement",
  1302.       range
  1303.     },
  1304.     {
  1305.       label: "ArrayList",
  1306.       kind: monaco.languages.CompletionItemKind.Snippet,
  1307.       insertText: "ArrayList<${1:type}> ${2:list} = new ArrayList<>();",
  1308.       insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
  1309.       documentation: "Creates an ArrayList",
  1310.       range
  1311.     },
  1312.     {
  1313.       label: "HashMap",
  1314.       kind: monaco.languages.CompletionItemKind.Snippet,
  1315.       insertText: "HashMap<${1:K}, ${2:V}> ${3:map} = new HashMap<>();",
  1316.       insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
  1317.       documentation: "Creates a HashMap",
  1318.       range
  1319.     },
  1320.     {
  1321.       label: "HashSet",
  1322.       kind: monaco.languages.CompletionItemKind.Snippet,
  1323.       insertText: "HashSet<${1:type}> ${2:set} = new HashSet<>();",
  1324.       insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
  1325.       documentation: "Creates a HashSet",
  1326.       range
  1327.     },
  1328.     {
  1329.       label: "LinkedList",
  1330.       kind: monaco.languages.CompletionItemKind.Snippet,
  1331.       insertText: "LinkedList<${1:type}> ${2:list} = new LinkedList<>();",
  1332.       insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
  1333.       documentation: "Creates a LinkedList",
  1334.       range
  1335.     },
  1336.     {
  1337.       label: "Stack",
  1338.       kind: monaco.languages.CompletionItemKind.Snippet,
  1339.       insertText: "Stack<${1:type}> ${2:stack} = new Stack<>();",
  1340.       insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
  1341.       documentation: "Creates a Stack",
  1342.       range
  1343.     },
  1344.     {
  1345.       label: "Queue",
  1346.       kind: monaco.languages.CompletionItemKind.Snippet,
  1347.       insertText: "Queue<${1:type}> ${2:queue} = new LinkedList<>(); // \u4F7F\u7528 LinkedList \u5B9E\u73B0\u961F\u5217",
  1348.       insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
  1349.       documentation: "Creates a Queue",
  1350.       range
  1351.     },
  1352.     {
  1353.       label: "PriorityQueue",
  1354.       kind: monaco.languages.CompletionItemKind.Snippet,
  1355.       insertText: "PriorityQueue<${1:type}> ${2:pq} = new PriorityQueue<>();",
  1356.       insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
  1357.       documentation: "Creates a PriorityQueue",
  1358.       range
  1359.     },
  1360.     {
  1361.       label: "Deque",
  1362.       kind: monaco.languages.CompletionItemKind.Snippet,
  1363.       insertText: "Deque<${1:type}> ${2:deque} = new ArrayDeque<>();",
  1364.       insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
  1365.       documentation: "Creates a Deque",
  1366.       range
  1367.     },
  1368.     {
  1369.       label: "Set",
  1370.       kind: monaco.languages.CompletionItemKind.Snippet,
  1371.       insertText: "Set<${1:type}> ${2:set} = new HashSet<>();",
  1372.       insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
  1373.       documentation: "Creates a Set",
  1374.       range
  1375.     },
  1376.     {
  1377.       label: "TreeMap",
  1378.       kind: monaco.languages.CompletionItemKind.Snippet,
  1379.       insertText: "TreeMap<${1:K}, ${2:V}> ${3:map} = new TreeMap<>();",
  1380.       insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
  1381.       documentation: "Creates a TreeMap",
  1382.       range
  1383.     },
  1384.     {
  1385.       label: "TreeSet",
  1386.       kind: monaco.languages.CompletionItemKind.Snippet,
  1387.       insertText: "TreeSet<${1:type}> ${2:set} = new TreeSet<>();",
  1388.       insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
  1389.       documentation: "Creates a TreeSet",
  1390.       range
  1391.     }
  1392.   ];
  1393. }
  1394.  
  1395. // src/java/index.ts
  1396. function initJavaCompletion(monaco) {
  1397.   monaco.languages.registerCompletionItemProvider("java", {
  1398.     provideCompletionItems: (model, position) => {
  1399.       const word = model.getWordUntilPosition(position);
  1400.       const range = getJavaRange(position, word);
  1401.       const code = model.getValue();
  1402.       const variables = extractJavaVariables(code, position);
  1403.       const variableSuggestions = [];
  1404.       variables.forEach(({ type }, name) => {
  1405.         variableSuggestions.push({
  1406.           label: name,
  1407.           kind: monaco.languages.CompletionItemKind.Variable,
  1408.           insertText: name,
  1409.           documentation: `Variable of type ${type}`,
  1410.           range
  1411.         });
  1412.       });
  1413.       const lineContent = model.getLineContent(position.lineNumber);
  1414.       const textBeforeCursor = lineContent.substring(0, position.column - 1).trim();
  1415.       const lastDotIndex = textBeforeCursor.lastIndexOf(".");
  1416.       let methodSuggestions = [];
  1417.       let isDotAfterVariable = false;
  1418.       if (lastDotIndex !== -1) {
  1419.         const varName = textBeforeCursor.substring(0, lastDotIndex).trim();
  1420.         if (variables.has(varName)) {
  1421.           const varInfo = variables.get(varName);
  1422.           isDotAfterVariable = true;
  1423.           switch (varInfo?.type) {
  1424.             case "ArrayList":
  1425.               methodSuggestions = getArrayListSuggestions(monaco, range);
  1426.               break;
  1427.             case "HashMap":
  1428.               methodSuggestions = getHashMapSuggestions(monaco, range);
  1429.               break;
  1430.             case "List":
  1431.               methodSuggestions = getListSuggestions(monaco, range);
  1432.               break;
  1433.             case "Set":
  1434.               methodSuggestions = getSetSuggestions(monaco, range);
  1435.               break;
  1436.             case "Queue":
  1437.               methodSuggestions = getQueueSuggestions2(monaco, range);
  1438.               break;
  1439.             case "Stack":
  1440.               methodSuggestions = getStackSuggestions2(monaco, range);
  1441.               break;
  1442.             case "Deque":
  1443.               methodSuggestions = getDequeSuggestions2(monaco, range);
  1444.               break;
  1445.             default:
  1446.               break;
  1447.           }
  1448.         }
  1449.       }
  1450.       if (!isDotAfterVariable) {
  1451.         const generalSuggestions = getGeneralSuggestions2(monaco, range);
  1452.         return {
  1453.           suggestions: [...generalSuggestions, ...variableSuggestions]
  1454.         };
  1455.       } else {
  1456.         return {
  1457.           suggestions: [...methodSuggestions]
  1458.         };
  1459.       }
  1460.     }
  1461.   });
  1462. }
  1463.  
  1464. // src/index.ts
  1465. function waitForMonaco() {
  1466.   return new Promise((resolve) => {
  1467.     const interval = setInterval(() => {
  1468.       if (window.monaco) {
  1469.         clearInterval(interval);
  1470.         resolve(window.monaco);
  1471.       }
  1472.     }, 100);
  1473.   });
  1474. }
  1475. async function init() {
  1476.   const monaco = await waitForMonaco();
  1477.   monaco.editor.onDidCreateEditor((editor) => {
  1478.     setTimeout(() => {
  1479.       editor.updateOptions({ suggestOnTriggerCharacters: true });
  1480.       editor.updateOptions({ quickSuggestions: { comments: "on", strings: "on", other: "on" } });
  1481.     }, 500);
  1482.   });
  1483.   initCppCompletion(monaco);
  1484.   initJavaCompletion(monaco);
  1485. }
  1486. window.addEventListener("load", init);