@enjoys/context-engine 1.0.0 → 1.0.2

package/data/completion/javascript.json

@@ -0,0 +1,914 @@
+{
+  "language": "javascript",
+  "completions": [
+    {
+      "label": "console.log",
+      "kind": 1,
+      "detail": "Log output to console",
+      "documentation": { "value": "Outputs a message to the web console.\n\n```js\nconsole.log('Hello, world!');\nconsole.log('Value:', myVar);\n```" },
+      "insertText": "console.log(${1:message})",
+      "insertTextRules": 4,
+      "sortText": "00_console_log"
+    },
+    {
+      "label": "console.error",
+      "kind": 1,
+      "detail": "Log error to console",
+      "documentation": { "value": "Outputs an error message to the web console.\n\n```js\nconsole.error('Something went wrong:', err);\n```" },
+      "insertText": "console.error(${1:message})",
+      "insertTextRules": 4,
+      "sortText": "00_console_error"
+    },
+    {
+      "label": "console.warn",
+      "kind": 1,
+      "detail": "Log warning to console",
+      "documentation": { "value": "Outputs a warning message to the web console.\n\n```js\nconsole.warn('Deprecation notice:', msg);\n```" },
+      "insertText": "console.warn(${1:message})",
+      "insertTextRules": 4,
+      "sortText": "00_console_warn"
+    },
+    {
+      "label": "console.info",
+      "kind": 1,
+      "detail": "Log informational message",
+      "documentation": { "value": "Outputs an informational message to the console.\n\n```js\nconsole.info('Server started on port', port);\n```" },
+      "insertText": "console.info(${1:message})",
+      "insertTextRules": 4,
+      "sortText": "00_console_info"
+    },
+    {
+      "label": "console.table",
+      "kind": 1,
+      "detail": "Display tabular data",
+      "documentation": { "value": "Displays tabular data as a table in the console.\n\n```js\nconsole.table([{ name: 'Alice', age: 30 }, { name: 'Bob', age: 25 }]);\n```" },
+      "insertText": "console.table(${1:data})",
+      "insertTextRules": 4,
+      "sortText": "00_console_table"
+    },
+    {
+      "label": "console.dir",
+      "kind": 1,
+      "detail": "Display object properties",
+      "documentation": { "value": "Displays an interactive listing of the properties of a specified JavaScript object.\n\n```js\nconsole.dir(document.body, { depth: 2 });\n```" },
+      "insertText": "console.dir(${1:obj})",
+      "insertTextRules": 4,
+      "sortText": "00_console_dir"
+    },
+    {
+      "label": "console.time",
+      "kind": 1,
+      "detail": "Start a timer",
+      "documentation": { "value": "Starts a timer you can use to track how long an operation takes.\n\n```js\nconsole.time('myTimer');\n// ...operation...\nconsole.timeEnd('myTimer');\n```" },
+      "insertText": "console.time('${1:label}')",
+      "insertTextRules": 4,
+      "sortText": "00_console_time"
+    },
+    {
+      "label": "console.timeEnd",
+      "kind": 1,
+      "detail": "Stop a timer",
+      "documentation": { "value": "Stops a timer that was previously started by calling `console.time()`.\n\n```js\nconsole.timeEnd('myTimer');\n```" },
+      "insertText": "console.timeEnd('${1:label}')",
+      "insertTextRules": 4,
+      "sortText": "00_console_timeEnd"
+    },
+    {
+      "label": "console.assert",
+      "kind": 1,
+      "detail": "Assert a condition",
+      "documentation": { "value": "Log a message and stack trace if the first argument is falsy.\n\n```js\nconsole.assert(x > 0, 'x must be positive');\n```" },
+      "insertText": "console.assert(${1:condition}, ${2:message})",
+      "insertTextRules": 4,
+      "sortText": "00_console_assert"
+    },
+    {
+      "label": "console.group",
+      "kind": 1,
+      "detail": "Start a console group",
+      "documentation": { "value": "Creates a new inline group in the console, indenting subsequent messages.\n\n```js\nconsole.group('Details');\nconsole.log('Name:', name);\nconsole.groupEnd();\n```" },
+      "insertText": "console.group('${1:label}');\n${2}\nconsole.groupEnd();",
+      "insertTextRules": 4,
+      "sortText": "00_console_group"
+    },
+    {
+      "label": "JSON.parse",
+      "kind": 1,
+      "detail": "Parse JSON string to object",
+      "documentation": { "value": "Parses a JSON string and returns the JavaScript value or object described by the string.\n\n```js\nconst obj = JSON.parse('{\"name\":\"Alice\"}');\n```\n\n**Throws** `SyntaxError` if the string is not valid JSON." },
+      "insertText": "JSON.parse(${1:text})",
+      "insertTextRules": 4,
+      "sortText": "01_json_parse"
+    },
+    {
+      "label": "JSON.stringify",
+      "kind": 1,
+      "detail": "Convert object to JSON string",
+      "documentation": { "value": "Converts a JavaScript value to a JSON string.\n\n```js\nconst json = JSON.stringify(obj, null, 2);\n```\n\n**Parameters:**\n- `value` — The value to convert\n- `replacer` — A function or array of strings to filter properties\n- `space` — Number of spaces for indentation" },
+      "insertText": "JSON.stringify(${1:value}, ${2:null}, ${3:2})",
+      "insertTextRules": 4,
+      "sortText": "01_json_stringify"
+    },
+    {
+      "label": "Array.from",
+      "kind": 1,
+      "detail": "Create array from iterable",
+      "documentation": { "value": "Creates a new, shallow-copied Array instance from an iterable or array-like object.\n\n```js\nArray.from('hello');        // ['h','e','l','l','o']\nArray.from({length: 3}, (_, i) => i); // [0, 1, 2]\n```" },
+      "insertText": "Array.from(${1:iterable})",
+      "insertTextRules": 4,
+      "sortText": "01_array_from"
+    },
+    {
+      "label": "Array.isArray",
+      "kind": 1,
+      "detail": "Check if value is an array",
+      "documentation": { "value": "Determines whether the passed value is an Array.\n\n```js\nArray.isArray([1, 2, 3]); // true\nArray.isArray('string');  // false\n```" },
+      "insertText": "Array.isArray(${1:value})",
+      "insertTextRules": 4,
+      "sortText": "01_array_isArray"
+    },
+    {
+      "label": ".map",
+      "kind": 0,
+      "detail": "Array.prototype.map()",
+      "documentation": { "value": "Creates a new array with the results of calling a function on every element.\n\n```js\nconst doubled = [1,2,3].map(x => x * 2); // [2,4,6]\n```" },
+      "insertText": ".map((${1:item}) => ${2})",
+      "insertTextRules": 4,
+      "sortText": "02_map"
+    },
+    {
+      "label": ".filter",
+      "kind": 0,
+      "detail": "Array.prototype.filter()",
+      "documentation": { "value": "Creates a new array with all elements that pass the test implemented by the provided function.\n\n```js\nconst evens = [1,2,3,4].filter(x => x % 2 === 0); // [2,4]\n```" },
+      "insertText": ".filter((${1:item}) => ${2})",
+      "insertTextRules": 4,
+      "sortText": "02_filter"
+    },
+    {
+      "label": ".reduce",
+      "kind": 0,
+      "detail": "Array.prototype.reduce()",
+      "documentation": { "value": "Executes a reducer function on each element, resulting in a single output value.\n\n```js\nconst sum = [1,2,3].reduce((acc, val) => acc + val, 0); // 6\n```" },
+      "insertText": ".reduce((${1:acc}, ${2:val}) => ${3}, ${4:initialValue})",
+      "insertTextRules": 4,
+      "sortText": "02_reduce"
+    },
+    {
+      "label": ".forEach",
+      "kind": 0,
+      "detail": "Array.prototype.forEach()",
+      "documentation": { "value": "Executes a provided function once for each array element.\n\n```js\n[1,2,3].forEach(item => console.log(item));\n```" },
+      "insertText": ".forEach((${1:item}) => {\n\t${2}\n})",
+      "insertTextRules": 4,
+      "sortText": "02_forEach"
+    },
+    {
+      "label": ".find",
+      "kind": 0,
+      "detail": "Array.prototype.find()",
+      "documentation": { "value": "Returns the first element in the array that satisfies the provided testing function.\n\n```js\nconst found = [1,5,10].find(x => x > 3); // 5\n```" },
+      "insertText": ".find((${1:item}) => ${2})",
+      "insertTextRules": 4,
+      "sortText": "02_find"
+    },
+    {
+      "label": ".findIndex",
+      "kind": 0,
+      "detail": "Array.prototype.findIndex()",
+      "documentation": { "value": "Returns the index of the first element that satisfies the provided testing function. Returns -1 if not found.\n\n```js\nconst idx = [1,5,10].findIndex(x => x > 3); // 1\n```" },
+      "insertText": ".findIndex((${1:item}) => ${2})",
+      "insertTextRules": 4,
+      "sortText": "02_findIndex"
+    },
+    {
+      "label": ".some",
+      "kind": 0,
+      "detail": "Array.prototype.some()",
+      "documentation": { "value": "Tests whether at least one element passes the provided function.\n\n```js\n[1,2,3].some(x => x > 2); // true\n```" },
+      "insertText": ".some((${1:item}) => ${2})",
+      "insertTextRules": 4,
+      "sortText": "02_some"
+    },
+    {
+      "label": ".every",
+      "kind": 0,
+      "detail": "Array.prototype.every()",
+      "documentation": { "value": "Tests whether all elements pass the provided function.\n\n```js\n[2,4,6].every(x => x % 2 === 0); // true\n```" },
+      "insertText": ".every((${1:item}) => ${2})",
+      "insertTextRules": 4,
+      "sortText": "02_every"
+    },
+    {
+      "label": ".includes",
+      "kind": 0,
+      "detail": "Array.prototype.includes()",
+      "documentation": { "value": "Determines whether an array includes a certain value.\n\n```js\n[1,2,3].includes(2); // true\n```" },
+      "insertText": ".includes(${1:value})",
+      "insertTextRules": 4,
+      "sortText": "02_includes"
+    },
+    {
+      "label": ".flat",
+      "kind": 0,
+      "detail": "Array.prototype.flat()",
+      "documentation": { "value": "Creates a new array with all sub-array elements concatenated into it recursively up to the specified depth.\n\n```js\n[1, [2, [3]]].flat(Infinity); // [1, 2, 3]\n```" },
+      "insertText": ".flat(${1:depth})",
+      "insertTextRules": 4,
+      "sortText": "02_flat"
+    },
+    {
+      "label": ".flatMap",
+      "kind": 0,
+      "detail": "Array.prototype.flatMap()",
+      "documentation": { "value": "Maps each element using a mapping function, then flattens the result into a new array.\n\n```js\n[1,2,3].flatMap(x => [x, x*2]); // [1,2,2,4,3,6]\n```" },
+      "insertText": ".flatMap((${1:item}) => ${2})",
+      "insertTextRules": 4,
+      "sortText": "02_flatMap"
+    },
+    {
+      "label": ".sort",
+      "kind": 0,
+      "detail": "Array.prototype.sort()",
+      "documentation": { "value": "Sorts the elements of an array in place and returns the sorted array.\n\n```js\n[3,1,2].sort((a, b) => a - b); // [1,2,3]\n```" },
+      "insertText": ".sort((${1:a}, ${2:b}) => ${3:a - b})",
+      "insertTextRules": 4,
+      "sortText": "02_sort"
+    },
+    {
+      "label": ".splice",
+      "kind": 0,
+      "detail": "Array.prototype.splice()",
+      "documentation": { "value": "Changes the contents of an array by removing or replacing existing elements and/or adding new elements in place.\n\n```js\nconst arr = [1,2,3,4];\narr.splice(1, 2); // removes 2 elements starting at index 1\n```" },
+      "insertText": ".splice(${1:start}, ${2:deleteCount})",
+      "insertTextRules": 4,
+      "sortText": "02_splice"
+    },
+    {
+      "label": ".slice",
+      "kind": 0,
+      "detail": "Array.prototype.slice()",
+      "documentation": { "value": "Returns a shallow copy of a portion of an array.\n\n```js\n[1,2,3,4].slice(1, 3); // [2, 3]\n```" },
+      "insertText": ".slice(${1:start}, ${2:end})",
+      "insertTextRules": 4,
+      "sortText": "02_slice"
+    },
+    {
+      "label": "Object.keys",
+      "kind": 1,
+      "detail": "Get object's own property names",
+      "documentation": { "value": "Returns an array of a given object's own enumerable property names.\n\n```js\nObject.keys({ a: 1, b: 2 }); // ['a', 'b']\n```" },
+      "insertText": "Object.keys(${1:obj})",
+      "insertTextRules": 4,
+      "sortText": "01_object_keys"
+    },
+    {
+      "label": "Object.values",
+      "kind": 1,
+      "detail": "Get object's own property values",
+      "documentation": { "value": "Returns an array of a given object's own enumerable property values.\n\n```js\nObject.values({ a: 1, b: 2 }); // [1, 2]\n```" },
+      "insertText": "Object.values(${1:obj})",
+      "insertTextRules": 4,
+      "sortText": "01_object_values"
+    },
+    {
+      "label": "Object.entries",
+      "kind": 1,
+      "detail": "Get object's own [key, value] pairs",
+      "documentation": { "value": "Returns an array of a given object's own enumerable [key, value] pairs.\n\n```js\nObject.entries({ a: 1, b: 2 }); // [['a',1], ['b',2]]\n```" },
+      "insertText": "Object.entries(${1:obj})",
+      "insertTextRules": 4,
+      "sortText": "01_object_entries"
+    },
+    {
+      "label": "Object.assign",
+      "kind": 1,
+      "detail": "Copy properties to target object",
+      "documentation": { "value": "Copies all enumerable own properties from one or more source objects to a target object.\n\n```js\nconst merged = Object.assign({}, defaults, options);\n```" },
+      "insertText": "Object.assign(${1:target}, ${2:source})",
+      "insertTextRules": 4,
+      "sortText": "01_object_assign"
+    },
+    {
+      "label": "Object.freeze",
+      "kind": 1,
+      "detail": "Freeze an object",
+      "documentation": { "value": "Freezes an object. A frozen object can no longer be changed.\n\n```js\nconst config = Object.freeze({ port: 3000, host: 'localhost' });\n```" },
+      "insertText": "Object.freeze(${1:obj})",
+      "insertTextRules": 4,
+      "sortText": "01_object_freeze"
+    },
+    {
+      "label": "Object.fromEntries",
+      "kind": 1,
+      "detail": "Create object from entries",
+      "documentation": { "value": "Transforms a list of key-value pairs into an object.\n\n```js\nObject.fromEntries([['a', 1], ['b', 2]]); // { a: 1, b: 2 }\nObject.fromEntries(new Map([['a', 1]]));\n```" },
+      "insertText": "Object.fromEntries(${1:entries})",
+      "insertTextRules": 4,
+      "sortText": "01_object_fromEntries"
+    },
+    {
+      "label": "Promise",
+      "kind": 5,
+      "detail": "Promise constructor",
+      "documentation": { "value": "Creates a new Promise object.\n\n```js\nconst p = new Promise((resolve, reject) => {\n  // async operation\n  resolve(result);\n});\n```" },
+      "insertText": "new Promise((resolve, reject) => {\n\t${1}\n})",
+      "insertTextRules": 4,
+      "sortText": "01_promise"
+    },
+    {
+      "label": "Promise.all",
+      "kind": 1,
+      "detail": "Wait for all promises",
+      "documentation": { "value": "Takes an iterable of promises and returns a single Promise that resolves when all have resolved.\n\n```js\nconst [a, b] = await Promise.all([fetchA(), fetchB()]);\n```" },
+      "insertText": "Promise.all([${1}])",
+      "insertTextRules": 4,
+      "sortText": "01_promise_all"
+    },
+    {
+      "label": "Promise.allSettled",
+      "kind": 1,
+      "detail": "Wait for all promises to settle",
+      "documentation": { "value": "Returns a promise that resolves after all given promises have either fulfilled or rejected.\n\n```js\nconst results = await Promise.allSettled([p1, p2, p3]);\nresults.forEach(r => console.log(r.status)); // 'fulfilled' or 'rejected'\n```" },
+      "insertText": "Promise.allSettled([${1}])",
+      "insertTextRules": 4,
+      "sortText": "01_promise_allSettled"
+    },
+    {
+      "label": "Promise.race",
+      "kind": 1,
+      "detail": "First promise to settle wins",
+      "documentation": { "value": "Returns a promise that fulfills or rejects as soon as one of the promises settles.\n\n```js\nconst result = await Promise.race([fetch(url), timeout(5000)]);\n```" },
+      "insertText": "Promise.race([${1}])",
+      "insertTextRules": 4,
+      "sortText": "01_promise_race"
+    },
+    {
+      "label": "Promise.any",
+      "kind": 1,
+      "detail": "First fulfilled promise",
+      "documentation": { "value": "Takes an iterable of promises and returns the first one that fulfills. Only rejects if all reject.\n\n```js\nconst fastest = await Promise.any([mirror1(), mirror2()]);\n```" },
+      "insertText": "Promise.any([${1}])",
+      "insertTextRules": 4,
+      "sortText": "01_promise_any"
+    },
+    {
+      "label": "fetch",
+      "kind": 1,
+      "detail": "Fetch API - HTTP requests",
+      "documentation": { "value": "Starts the process of fetching a resource from the network, returning a promise.\n\n```js\nconst response = await fetch('https://api.example.com/data');\nconst data = await response.json();\n```" },
+      "insertText": "fetch('${1:url}'${2:, {\n\tmethod: '${3:GET}',\n\theaders: { 'Content-Type': 'application/json' },\n\tbody: JSON.stringify(${4:data})\n\\}})",
+      "insertTextRules": 4,
+      "sortText": "00_fetch"
+    },
+    {
+      "label": "setTimeout",
+      "kind": 1,
+      "detail": "Execute after delay",
+      "documentation": { "value": "Sets a timer which executes a function once the timer expires.\n\n```js\nsetTimeout(() => {\n  console.log('Delayed!');\n}, 1000);\n```" },
+      "insertText": "setTimeout(() => {\n\t${1}\n}, ${2:1000})",
+      "insertTextRules": 4,
+      "sortText": "01_setTimeout"
+    },
+    {
+      "label": "setInterval",
+      "kind": 1,
+      "detail": "Execute repeatedly at interval",
+      "documentation": { "value": "Repeatedly calls a function with a fixed time delay between each call.\n\n```js\nconst id = setInterval(() => {\n  console.log('Tick');\n}, 1000);\nclearInterval(id);\n```" },
+      "insertText": "setInterval(() => {\n\t${1}\n}, ${2:1000})",
+      "insertTextRules": 4,
+      "sortText": "01_setInterval"
+    },
+    {
+      "label": "parseInt",
+      "kind": 1,
+      "detail": "Parse string to integer",
+      "documentation": { "value": "Parses a string argument and returns an integer of the specified radix.\n\n```js\nparseInt('42');     // 42\nparseInt('0xFF', 16); // 255\n```" },
+      "insertText": "parseInt(${1:string}, ${2:10})",
+      "insertTextRules": 4,
+      "sortText": "01_parseInt"
+    },
+    {
+      "label": "parseFloat",
+      "kind": 1,
+      "detail": "Parse string to float",
+      "documentation": { "value": "Parses a string and returns a floating point number.\n\n```js\nparseFloat('3.14'); // 3.14\n```" },
+      "insertText": "parseFloat(${1:string})",
+      "insertTextRules": 4,
+      "sortText": "01_parseFloat"
+    },
+    {
+      "label": "Number.isNaN",
+      "kind": 1,
+      "detail": "Check if value is NaN",
+      "documentation": { "value": "Determines whether the passed value is NaN (more reliable than global `isNaN`).\n\n```js\nNumber.isNaN(NaN);        // true\nNumber.isNaN(undefined);  // false\n```" },
+      "insertText": "Number.isNaN(${1:value})",
+      "insertTextRules": 4,
+      "sortText": "01_number_isNaN"
+    },
+    {
+      "label": "Number.isFinite",
+      "kind": 1,
+      "detail": "Check if value is finite",
+      "documentation": { "value": "Determines whether the passed value is a finite number.\n\n```js\nNumber.isFinite(42);       // true\nNumber.isFinite(Infinity); // false\n```" },
+      "insertText": "Number.isFinite(${1:value})",
+      "insertTextRules": 4,
+      "sortText": "01_number_isFinite"
+    },
+    {
+      "label": "Math.max",
+      "kind": 1,
+      "detail": "Return the largest value",
+      "documentation": { "value": "Returns the largest of zero or more numbers.\n\n```js\nMath.max(1, 5, 3);       // 5\nMath.max(...[1, 5, 3]);  // 5\n```" },
+      "insertText": "Math.max(${1})",
+      "insertTextRules": 4,
+      "sortText": "01_math_max"
+    },
+    {
+      "label": "Math.min",
+      "kind": 1,
+      "detail": "Return the smallest value",
+      "documentation": { "value": "Returns the smallest of zero or more numbers.\n\n```js\nMath.min(1, 5, 3);       // 1\nMath.min(...[1, 5, 3]);  // 1\n```" },
+      "insertText": "Math.min(${1})",
+      "insertTextRules": 4,
+      "sortText": "01_math_min"
+    },
+    {
+      "label": "Math.floor",
+      "kind": 1,
+      "detail": "Round down to integer",
+      "documentation": { "value": "Returns the largest integer less than or equal to a given number.\n\n```js\nMath.floor(4.7);  // 4\nMath.floor(-4.1); // -5\n```" },
+      "insertText": "Math.floor(${1:value})",
+      "insertTextRules": 4,
+      "sortText": "01_math_floor"
+    },
+    {
+      "label": "Math.ceil",
+      "kind": 1,
+      "detail": "Round up to integer",
+      "documentation": { "value": "Returns the smallest integer greater than or equal to a given number.\n\n```js\nMath.ceil(4.1); // 5\n```" },
+      "insertText": "Math.ceil(${1:value})",
+      "insertTextRules": 4,
+      "sortText": "01_math_ceil"
+    },
+    {
+      "label": "Math.round",
+      "kind": 1,
+      "detail": "Round to nearest integer",
+      "documentation": { "value": "Returns the value of a number rounded to the nearest integer.\n\n```js\nMath.round(4.5); // 5\nMath.round(4.4); // 4\n```" },
+      "insertText": "Math.round(${1:value})",
+      "insertTextRules": 4,
+      "sortText": "01_math_round"
+    },
+    {
+      "label": "Math.random",
+      "kind": 1,
+      "detail": "Random number [0, 1)",
+      "documentation": { "value": "Returns a pseudo-random number between 0 (inclusive) and 1 (exclusive).\n\n```js\nconst rand = Math.random();\nconst randInt = Math.floor(Math.random() * 10); // 0-9\n```" },
+      "insertText": "Math.random()",
+      "insertTextRules": 4,
+      "sortText": "01_math_random"
+    },
+    {
+      "label": "Map",
+      "kind": 5,
+      "detail": "Map constructor",
+      "documentation": { "value": "The `Map` object holds key-value pairs and remembers the original insertion order.\n\n```js\nconst map = new Map();\nmap.set('key', 'value');\nmap.get('key'); // 'value'\nmap.has('key'); // true\nmap.size;       // 1\n```" },
+      "insertText": "new Map(${1})",
+      "insertTextRules": 4,
+      "sortText": "01_map"
+    },
+    {
+      "label": "Set",
+      "kind": 5,
+      "detail": "Set constructor",
+      "documentation": { "value": "The `Set` object lets you store unique values of any type.\n\n```js\nconst set = new Set([1, 2, 3, 2]);\nset.size;       // 3\nset.has(2);     // true\nset.add(4);\n```" },
+      "insertText": "new Set(${1})",
+      "insertTextRules": 4,
+      "sortText": "01_set"
+    },
+    {
+      "label": "WeakMap",
+      "kind": 5,
+      "detail": "WeakMap constructor",
+      "documentation": { "value": "A `WeakMap` is a collection of key/value pairs whose keys must be objects, held weakly (allow garbage collection).\n\n```js\nconst wm = new WeakMap();\nconst obj = {};\nwm.set(obj, 'metadata');\n```" },
+      "insertText": "new WeakMap()",
+      "insertTextRules": 4,
+      "sortText": "01_weakmap"
+    },
+    {
+      "label": "WeakSet",
+      "kind": 5,
+      "detail": "WeakSet constructor",
+      "documentation": { "value": "A `WeakSet` is a collection of objects, held weakly.\n\n```js\nconst ws = new WeakSet();\nconst obj = {};\nws.add(obj);\nws.has(obj); // true\n```" },
+      "insertText": "new WeakSet()",
+      "insertTextRules": 4,
+      "sortText": "01_weakset"
+    },
+    {
+      "label": "structuredClone",
+      "kind": 1,
+      "detail": "Deep clone a value",
+      "documentation": { "value": "Creates a deep clone of a given value using the structured clone algorithm.\n\n```js\nconst clone = structuredClone({ nested: { data: [1, 2] } });\n```" },
+      "insertText": "structuredClone(${1:value})",
+      "insertTextRules": 4,
+      "sortText": "00_structuredClone"
+    },
+    {
+      "label": "queueMicrotask",
+      "kind": 1,
+      "detail": "Queue a microtask",
+      "documentation": { "value": "Queues a microtask to be executed before control returns to the event loop.\n\n```js\nqueueMicrotask(() => {\n  console.log('Runs as microtask');\n});\n```" },
+      "insertText": "queueMicrotask(() => {\n\t${1}\n})",
+      "insertTextRules": 4,
+      "sortText": "01_queueMicrotask"
+    },
+    {
+      "label": "globalThis",
+      "kind": 4,
+      "detail": "Global this value",
+      "documentation": { "value": "The `globalThis` property provides a standard way of accessing the global `this` value across environments.\n\n```js\nglobalThis.myGlobal = 42;\n```" },
+      "insertText": "globalThis",
+      "insertTextRules": 1,
+      "sortText": "01_globalThis"
+    },
+    {
+      "label": "Symbol",
+      "kind": 1,
+      "detail": "Create unique symbol",
+      "documentation": { "value": "Creates an anonymous, unique symbol value.\n\n```js\nconst id = Symbol('id');\nconst obj = { [id]: 123 };\n```" },
+      "insertText": "Symbol(${1:'description'})",
+      "insertTextRules": 4,
+      "sortText": "01_symbol"
+    },
+    {
+      "label": "Proxy",
+      "kind": 5,
+      "detail": "Create a Proxy object",
+      "documentation": { "value": "Creates an object that wraps another object and intercepts fundamental operations.\n\n```js\nconst handler = {\n  get(target, prop) {\n    return prop in target ? target[prop] : 'default';\n  }\n};\nconst proxy = new Proxy({}, handler);\n```" },
+      "insertText": "new Proxy(${1:target}, {\n\tget(target, prop) {\n\t\t${2}\n\t}\n})",
+      "insertTextRules": 4,
+      "sortText": "01_proxy"
+    },
+    {
+      "label": "Reflect",
+      "kind": 9,
+      "detail": "Reflect namespace",
+      "documentation": { "value": "Provides methods for interceptable JavaScript operations. Same methods as proxy handler traps.\n\n```js\nReflect.has(obj, 'key');\nReflect.ownKeys(obj);\nReflect.apply(fn, thisArg, args);\n```" },
+      "insertText": "Reflect.${1:method}(${2})",
+      "insertTextRules": 4,
+      "sortText": "01_reflect"
+    },
+    {
+      "label": { "label": "async function", "detail": " declaration", "description": "ES2017+" },
+      "kind": 15,
+      "detail": "Async function snippet",
+      "documentation": { "value": "Declares an asynchronous function that returns a Promise.\n\n```js\nasync function fetchData(url) {\n  const res = await fetch(url);\n  return res.json();\n}\n```" },
+      "insertText": "async function ${1:name}(${2:params}) {\n\t${3}\n}",
+      "insertTextRules": 4,
+      "sortText": "00_async_function"
+    },
+    {
+      "label": { "label": "arrow function", "detail": " expression", "description": "ES6+" },
+      "kind": 15,
+      "detail": "Arrow function snippet",
+      "documentation": { "value": "Arrow function expression with concise syntax.\n\n```js\nconst add = (a, b) => a + b;\nconst greet = name => `Hello, ${name}`;\n```" },
+      "insertText": "const ${1:name} = (${2:params}) => {\n\t${3}\n};",
+      "insertTextRules": 4,
+      "sortText": "00_arrow_function"
+    },
+    {
+      "label": { "label": "try...catch", "detail": " block", "description": "Error handling" },
+      "kind": 15,
+      "detail": "Try-catch error handling",
+      "documentation": { "value": "Wraps code in a try-catch block for error handling.\n\n```js\ntry {\n  riskyOperation();\n} catch (error) {\n  console.error(error);\n}\n```" },
+      "insertText": "try {\n\t${1}\n} catch (${2:error}) {\n\t${3:console.error($2);}\n}",
+      "insertTextRules": 4,
+      "sortText": "00_try_catch"
+    },
+    {
+      "label": { "label": "for...of", "detail": " loop", "description": "ES6+ iterable loop" },
+      "kind": 15,
+      "detail": "For-of loop over iterable",
+      "documentation": { "value": "Iterates over iterable objects (Arrays, Strings, Maps, Sets, etc.).\n\n```js\nfor (const item of [1, 2, 3]) {\n  console.log(item);\n}\n```" },
+      "insertText": "for (const ${1:item} of ${2:iterable}) {\n\t${3}\n}",
+      "insertTextRules": 4,
+      "sortText": "00_for_of"
+    },
+    {
+      "label": { "label": "for...in", "detail": " loop", "description": "Enumerate properties" },
+      "kind": 15,
+      "detail": "For-in loop over properties",
+      "documentation": { "value": "Iterates over enumerable string properties of an object.\n\n```js\nfor (const key in obj) {\n  if (obj.hasOwnProperty(key)) {\n    console.log(key, obj[key]);\n  }\n}\n```" },
+      "insertText": "for (const ${1:key} in ${2:obj}) {\n\t${3}\n}",
+      "insertTextRules": 4,
+      "sortText": "00_for_in"
+    },
+    {
+      "label": { "label": "class", "detail": " declaration", "description": "ES6+ class" },
+      "kind": 15,
+      "detail": "Class declaration snippet",
+      "documentation": { "value": "Declares a class with constructor.\n\n```js\nclass Animal {\n  constructor(name) {\n    this.name = name;\n  }\n  speak() {\n    return `${this.name} makes a sound.`;\n  }\n}\n```" },
+      "insertText": "class ${1:ClassName} {\n\tconstructor(${2:params}) {\n\t\t${3}\n\t}\n\n\t${4:method}(${5}) {\n\t\t${6}\n\t}\n}",
+      "insertTextRules": 4,
+      "sortText": "00_class"
+    },
+    {
+      "label": { "label": "import", "detail": " ES module", "description": "ES6+" },
+      "kind": 15,
+      "detail": "Import statement",
+      "documentation": { "value": "Import bindings from a module.\n\n```js\nimport { useState, useEffect } from 'react';\nimport defaultExport from 'module';\nimport * as name from 'module';\n```" },
+      "insertText": "import { ${1:name} } from '${2:module}';",
+      "insertTextRules": 4,
+      "sortText": "00_import"
+    },
+    {
+      "label": { "label": "export default", "detail": " ES module", "description": "ES6+" },
+      "kind": 15,
+      "detail": "Default export",
+      "documentation": { "value": "Export a default value from a module.\n\n```js\nexport default function myFunc() { }\nexport default class MyClass { }\n```" },
+      "insertText": "export default ${1}",
+      "insertTextRules": 4,
+      "sortText": "00_export_default"
+    },
+    {
+      "label": { "label": "export", "detail": " named", "description": "ES6+" },
+      "kind": 15,
+      "detail": "Named export",
+      "documentation": { "value": "Export named bindings from a module.\n\n```js\nexport const myVar = 42;\nexport function myFunc() { }\nexport { name1, name2 };\n```" },
+      "insertText": "export { ${1} };",
+      "insertTextRules": 4,
+      "sortText": "00_export"
+    },
+    {
+      "label": { "label": "destructure object", "detail": " assignment", "description": "ES6+" },
+      "kind": 15,
+      "detail": "Object destructuring",
+      "documentation": { "value": "Extract properties from objects into variables.\n\n```js\nconst { name, age, ...rest } = person;\n```" },
+      "insertText": "const { ${1:prop} } = ${2:obj};",
+      "insertTextRules": 4,
+      "sortText": "00_destructure_obj"
+    },
+    {
+      "label": { "label": "destructure array", "detail": " assignment", "description": "ES6+" },
+      "kind": 15,
+      "detail": "Array destructuring",
+      "documentation": { "value": "Extract elements from arrays into variables.\n\n```js\nconst [first, second, ...rest] = [1, 2, 3, 4];\n```" },
+      "insertText": "const [${1:first}, ${2:second}] = ${3:arr};",
+      "insertTextRules": 4,
+      "sortText": "00_destructure_arr"
+    },
+    {
+      "label": { "label": "template literal", "detail": " string", "description": "ES6+" },
+      "kind": 15,
+      "detail": "Template literal string",
+      "documentation": { "value": "Allows embedded expressions and multi-line strings.\n\n```js\nconst msg = `Hello, ${name}! You are ${age} years old.`;\n```" },
+      "insertText": "`${1:text} \\${${2:expression}}`",
+      "insertTextRules": 4,
+      "sortText": "00_template_literal"
+    },
+    {
+      "label": { "label": "spread operator", "detail": " ...", "description": "ES6+" },
+      "kind": 15,
+      "detail": "Spread/rest operator",
+      "documentation": { "value": "Expand an iterable or collect remaining elements.\n\n```js\nconst merged = [...arr1, ...arr2];\nconst copy = { ...original, newProp: 'val' };\nfunction fn(...args) { }\n```" },
+      "insertText": "...${1:iterable}",
+      "insertTextRules": 4,
+      "sortText": "00_spread"
+    },
+    {
+      "label": { "label": "optional chaining", "detail": " ?.", "description": "ES2020+" },
+      "kind": 15,
+      "detail": "Optional chaining operator",
+      "documentation": { "value": "Access deeply nested properties without checking each level.\n\n```js\nconst city = user?.address?.city;\nconst result = obj?.method?.();\n```" },
+      "insertText": "${1:obj}?.${2:prop}",
+      "insertTextRules": 4,
+      "sortText": "00_optional_chaining"
+    },
+    {
+      "label": { "label": "nullish coalescing", "detail": " ??", "description": "ES2020+" },
+      "kind": 15,
+      "detail": "Nullish coalescing operator",
+      "documentation": { "value": "Returns the right-hand operand when the left-hand is null or undefined.\n\n```js\nconst value = input ?? 'default';\n```" },
+      "insertText": "${1:value} ?? ${2:defaultValue}",
+      "insertTextRules": 4,
+      "sortText": "00_nullish_coalescing"
+    },
+    {
+      "label": "String.prototype.replaceAll",
+      "kind": 0,
+      "detail": "Replace all occurrences",
+      "documentation": { "value": "Returns a new string with all matches of a pattern replaced.\n\n```js\n'aaa'.replaceAll('a', 'b'); // 'bbb'\n```" },
+      "insertText": ".replaceAll(${1:search}, ${2:replacement})",
+      "insertTextRules": 4,
+      "sortText": "02_replaceAll"
+    },
+    {
+      "label": ".at",
+      "kind": 0,
+      "detail": "Array/String.prototype.at()",
+      "documentation": { "value": "Returns the element at the given index, supporting negative indexing.\n\n```js\n[1,2,3].at(-1); // 3\n'hello'.at(0);   // 'h'\n```" },
+      "insertText": ".at(${1:index})",
+      "insertTextRules": 4,
+      "sortText": "02_at"
+    },
+    {
+      "label": "AbortController",
+      "kind": 5,
+      "detail": "AbortController for cancellation",
+      "documentation": { "value": "Allows you to abort one or more Web requests as and when desired.\n\n```js\nconst controller = new AbortController();\nfetch(url, { signal: controller.signal });\ncontroller.abort();\n```" },
+      "insertText": "const ${1:controller} = new AbortController();\nconst ${2:signal} = ${1:controller}.signal;",
+      "insertTextRules": 4,
+      "sortText": "01_abortcontroller"
+    },
+    {
+      "label": "URL",
+      "kind": 5,
+      "detail": "URL constructor",
+      "documentation": { "value": "Creates and returns a URL object from a URL string.\n\n```js\nconst url = new URL('https://example.com/path?q=1');\nurl.hostname;    // 'example.com'\nurl.searchParams.get('q'); // '1'\n```" },
+      "insertText": "new URL(${1:'https://example.com'})",
+      "insertTextRules": 4,
+      "sortText": "01_url"
+    },
+    {
+      "label": "URLSearchParams",
+      "kind": 5,
+      "detail": "URL query string utility",
+      "documentation": { "value": "Utility methods to work with the query string of a URL.\n\n```js\nconst params = new URLSearchParams({ page: 1, limit: 10 });\nparams.toString(); // 'page=1&limit=10'\n```" },
+      "insertText": "new URLSearchParams(${1})",
+      "insertTextRules": 4,
+      "sortText": "01_urlsearchparams"
+    },
+    {
+      "label": "TextEncoder",
+      "kind": 5,
+      "detail": "Encode string to Uint8Array",
+      "documentation": { "value": "Takes a stream of code points as input and emits a stream of UTF-8 bytes.\n\n```js\nconst encoder = new TextEncoder();\nconst bytes = encoder.encode('Hello');\n```" },
+      "insertText": "new TextEncoder().encode(${1:string})",
+      "insertTextRules": 4,
+      "sortText": "01_textencoder"
+    },
+    {
+      "label": "TextDecoder",
+      "kind": 5,
+      "detail": "Decode bytes to string",
+      "documentation": { "value": "Represents a decoder for a specific text encoding (defaults to UTF-8).\n\n```js\nconst decoder = new TextDecoder();\nconst text = decoder.decode(uint8Array);\n```" },
+      "insertText": "new TextDecoder().decode(${1:buffer})",
+      "insertTextRules": 4,
+      "sortText": "01_textdecoder"
+    },
+    {
+      "label": "crypto.randomUUID",
+      "kind": 1,
+      "detail": "Generate random UUID",
+      "documentation": { "value": "Generates a random v4 UUID.\n\n```js\nconst uuid = crypto.randomUUID();\n// 'a1b2c3d4-e5f6-4a5b-8c7d-9e0f1a2b3c4d'\n```" },
+      "insertText": "crypto.randomUUID()",
+      "insertTextRules": 1,
+      "sortText": "01_crypto_uuid"
+    },
+    {
+      "label": "atob",
+      "kind": 1,
+      "detail": "Decode base64 string",
+      "documentation": { "value": "Decodes a string of data which has been encoded using Base64 encoding.\n\n```js\natob('SGVsbG8='); // 'Hello'\n```" },
+      "insertText": "atob(${1:encodedString})",
+      "insertTextRules": 4,
+      "sortText": "01_atob"
+    },
+    {
+      "label": "btoa",
+      "kind": 1,
+      "detail": "Encode to base64 string",
+      "documentation": { "value": "Creates a Base64-encoded ASCII string from a binary string.\n\n```js\nbtoa('Hello'); // 'SGVsbG8='\n```" },
+      "insertText": "btoa(${1:string})",
+      "insertTextRules": 4,
+      "sortText": "01_btoa"
+    },
+    {
+      "label": "const",
+      "kind": 14,
+      "detail": "Block-scoped constant",
+      "documentation": { "value": "Declares a block-scoped constant. The value cannot be reassigned.\n\n```js\nconst PI = 3.14159;\nconst config = { port: 3000 };\n```" },
+      "insertText": "const ${1:name} = ${2:value};",
+      "insertTextRules": 4,
+      "sortText": "00_const"
+    },
+    {
+      "label": "let",
+      "kind": 14,
+      "detail": "Block-scoped variable",
+      "documentation": { "value": "Declares a block-scoped local variable, optionally initializing it.\n\n```js\nlet count = 0;\ncount++;\n```" },
+      "insertText": "let ${1:name} = ${2:value};",
+      "insertTextRules": 4,
+      "sortText": "00_let"
+    },
+    {
+      "label": "async/await",
+      "kind": 14,
+      "detail": "Async/await syntax",
+      "documentation": { "value": "Write asynchronous code in a synchronous style.\n\n```js\nasync function main() {\n  const data = await fetchData();\n  console.log(data);\n}\n```" },
+      "insertText": "const ${1:result} = await ${2:promise};",
+      "insertTextRules": 4,
+      "sortText": "00_async_await"
+    },
+    {
+      "label": "typeof",
+      "kind": 14,
+      "detail": "Type checking operator",
+      "documentation": { "value": "Returns a string indicating the type of the operand.\n\n```js\ntypeof 42;          // 'number'\ntypeof 'hello';     // 'string'\ntypeof undefined;   // 'undefined'\ntypeof null;        // 'object' (historical bug)\n```" },
+      "insertText": "typeof ${1:value}",
+      "insertTextRules": 4,
+      "sortText": "01_typeof"
+    },
+    {
+      "label": "instanceof",
+      "kind": 14,
+      "detail": "Instance type checking",
+      "documentation": { "value": "Tests whether the prototype property of a constructor appears in the prototype chain.\n\n```js\n[] instanceof Array;  // true\nnew Date() instanceof Date; // true\n```" },
+      "insertText": "${1:obj} instanceof ${2:Constructor}",
+      "insertTextRules": 4,
+      "sortText": "01_instanceof"
+    },
+    {
+      "label": "RegExp",
+      "kind": 5,
+      "detail": "Regular expression constructor",
+      "documentation": { "value": "Creates a regular expression object for matching text with a pattern.\n\n```js\nconst re = new RegExp('\\\\d+', 'g');\nconst re2 = /\\d+/g;\n'abc123'.match(re); // ['123']\n```" },
+      "insertText": "new RegExp('${1:pattern}', '${2:flags}')",
+      "insertTextRules": 4,
+      "sortText": "01_regexp"
+    },
+    {
+      "label": "Error",
+      "kind": 5,
+      "detail": "Error constructor",
+      "documentation": { "value": "Creates an error object.\n\n```js\nthrow new Error('Something went wrong');\n```\n\nBuilt-in error types: `TypeError`, `RangeError`, `SyntaxError`, `ReferenceError`, `URIError`, `EvalError`" },
+      "insertText": "new Error('${1:message}')",
+      "insertTextRules": 4,
+      "sortText": "01_error"
+    },
+    {
+      "label": "Date",
+      "kind": 5,
+      "detail": "Date constructor",
+      "documentation": { "value": "Creates a JavaScript `Date` instance that represents a single moment in time.\n\n```js\nconst now = new Date();\nconst specific = new Date('2024-01-15');\nnow.toISOString(); // '2024-...'\n```" },
+      "insertText": "new Date(${1})",
+      "insertTextRules": 4,
+      "sortText": "01_date"
+    },
+    {
+      "label": "Intl.DateTimeFormat",
+      "kind": 5,
+      "detail": "Internationalized date formatting",
+      "documentation": { "value": "Enables language-sensitive date and time formatting.\n\n```js\nnew Intl.DateTimeFormat('en-US', {\n  dateStyle: 'long',\n  timeStyle: 'short'\n}).format(new Date());\n```" },
+      "insertText": "new Intl.DateTimeFormat('${1:en-US}', {\n\t${2:dateStyle: 'long'}\n}).format(${3:date})",
+      "insertTextRules": 4,
+      "sortText": "01_intl_datetime"
+    },
+    {
+      "label": "Intl.NumberFormat",
+      "kind": 5,
+      "detail": "Internationalized number formatting",
+      "documentation": { "value": "Enables language-sensitive number formatting.\n\n```js\nnew Intl.NumberFormat('en-US', {\n  style: 'currency',\n  currency: 'USD'\n}).format(1234.56); // '$1,234.56'\n```" },
+      "insertText": "new Intl.NumberFormat('${1:en-US}', {\n\t${2:style: 'decimal'}\n}).format(${3:number})",
+      "insertTextRules": 4,
+      "sortText": "01_intl_number"
+    },
+    {
+      "label": "Iterator.from",
+      "kind": 1,
+      "detail": "Create iterator from iterable (ES2025)",
+      "documentation": { "value": "Creates an Iterator object from an iterable or iterator-like object.\n\n```js\nconst it = Iterator.from([1, 2, 3]);\nit.map(x => x * 2).toArray(); // [2, 4, 6]\n```" },
+      "insertText": "Iterator.from(${1:iterable})",
+      "insertTextRules": 4,
+      "sortText": "01_iterator_from"
+    },
+    {
+      "label": "Object.groupBy",
+      "kind": 1,
+      "detail": "Group iterable elements (ES2024)",
+      "documentation": { "value": "Groups elements of an iterable according to a callback function.\n\n```js\nObject.groupBy([1,2,3,4,5], n => n % 2 === 0 ? 'even' : 'odd');\n// { odd: [1,3,5], even: [2,4] }\n```" },
+      "insertText": "Object.groupBy(${1:iterable}, (${2:item}) => ${3})",
+      "insertTextRules": 4,
+      "sortText": "01_object_groupBy"
+    },
+    {
+      "label": "Array.fromAsync",
+      "kind": 1,
+      "detail": "Array from async iterable (ES2024)",
+      "documentation": { "value": "Creates a new Array from an async iterable, iterable, or array-like object.\n\n```js\nconst arr = await Array.fromAsync(asyncGenerator());\n```" },
+      "insertText": "await Array.fromAsync(${1:asyncIterable})",
+      "insertTextRules": 4,
+      "sortText": "01_array_fromAsync"
+    },
+    {
+      "label": "using",
+      "kind": 14,
+      "detail": "Explicit Resource Management (ES2025)",
+      "documentation": { "value": "Declares a resource that is automatically disposed when it goes out of scope.\n\n```js\n{\n  using handle = getFileHandle();\n  // handle[Symbol.dispose]() called automatically\n}\n```" },
+      "insertText": "using ${1:resource} = ${2:expression};",
+      "insertTextRules": 4,
+      "sortText": "00_using"
+    }
+  ]
+}