diff options
Diffstat (limited to 'js/baba-yaga/dev/vscode')
24 files changed, 4651 insertions, 0 deletions
diff --git a/js/baba-yaga/dev/vscode/LICENSE b/js/baba-yaga/dev/vscode/LICENSE new file mode 100644 index 0000000..01915fa --- /dev/null +++ b/js/baba-yaga/dev/vscode/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2024 Baba Yaga + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/js/baba-yaga/dev/vscode/README.md b/js/baba-yaga/dev/vscode/README.md new file mode 100644 index 0000000..c144519 --- /dev/null +++ b/js/baba-yaga/dev/vscode/README.md @@ -0,0 +1,312 @@ +# Baba Yaga VS Code Extension + +Advanced language support for the Baba Yaga programming language with Tree-sitter parsing, type hints, function references, and intelligent code completion. + +## Features + +### **Core Language Support** +- **Syntax Highlighting**: Full support for all Baba Yaga syntax elements +- **File Association**: Automatic detection of `.baba` files +- **Bracket Matching**: Auto-closing brackets, parentheses, and braces +- **Comment Handling**: Toggle line and block comments +- **Indentation**: Smart indentation for Baba Yaga code structure + +### **Intelligent Features** +- **Type Hints**: Multiple display modes - hover, inline, or above expressions (Elm-style) +- **Function References**: Go to definition (F12) and find all references (Shift+F12) +- **Auto-completion**: Context-aware suggestions for functions, keywords, and types +- **Error Checking**: Real-time syntax validation and error detection +- **Code Snippets**: Quick templates for common patterns +- **Markdown Support**: Syntax highlighting in Baba Yaga code blocks + +### **Advanced Capabilities** +- **Tree-sitter Parsing**: Accurate syntax tree for better analysis +- **Function Signatures**: Detailed parameter and return type information +- **Built-in Function Support**: Complete coverage of `io.*`, `str.*`, `math.*` functions +- **Pattern Matching**: Special support for `when` expressions +- **Result Type Handling**: Intelligent handling of `Ok`/`Err` patterns + +## Installation + +### Method 1: Build from Source +```bash +cd dev/vscode +npm install +npm run compile +vsce package +# Install the generated .vsix file in VS Code +``` + +### Method 2: Development Mode +```bash +cd dev/vscode +npm install +npm run watch +# Press F5 in VS Code to launch extension in development mode +``` + +### Method 3: Manual Installation +1. Copy the extension files to your VS Code extensions directory +2. Restart VS Code +3. Open a `.baba` file to activate the extension + +## Configuration + +The extension provides several configuration options in VS Code settings: + +```json +{ + "baba-yaga.enableTypeHints": true, + "baba-yaga.enableFunctionReferences": true, + "baba-yaga.enableAutoComplete": true, + "baba-yaga.enableErrorChecking": true, + "baba-yaga.enableMarkdownSupport": true, + "baba-yaga.typeHintMode": "above" +} +``` + +### Configuration Options +- **`enableTypeHints`**: Show type hints and function signatures on hover +- **`enableFunctionReferences`**: Enable go-to-definition and find references +- **`enableAutoComplete`**: Enable intelligent code completion +- **`enableErrorChecking`**: Enable real-time error checking (disabled by default to prevent false semicolon warnings) +- **`enableMarkdownSupport`**: Enable syntax highlighting in Markdown code blocks +- **`typeHintMode`**: Type hint display mode - see below for details + +### Type Hint Modes + +The extension supports three different type hint display modes: + +#### **`"none"` - Hover Only** +```baba +result : add(5, 3); // No visual hints, hover to see types +``` +- Type information only appears when hovering over symbols +- Clean, minimal interface +- Best for experienced developers who don't need constant type reminders + +#### **`"inline"` - After Expressions** +```baba +result : add(5, 3); : Int +greeting : str.concat("Hello", name); : String +``` +- Type hints appear directly after expressions +- Compact display +- Good for quick type reference without breaking code flow + +#### **`"above"` - Elm Style (Default)** +```baba + : Int +result : add(5, 3); + : String +greeting : str.concat("Hello", name); +``` +- Type hints appear above expressions, right-aligned +- Clean separation between types and code +- Matches Elm language conventions +- Most readable for complex type signatures + +## Usage + +### Basic Syntax Highlighting +Open any `.baba` file and enjoy full syntax highlighting with: +- Keywords: `when`, `then`, `is`, `Ok`, `Err`, `true`, `false`, etc. +- Types: `Bool`, `Int`, `Float`, `String`, `List`, `Table`, `Result`, `Number` +- Operators: `->`, `=>`, `+`, `-`, `*`, `/`, `%`, `=`, `!=`, `>`, `<`, `>=`, `<=`, `..` +- Built-in functions: Complete `io.*`, `str.*`, `math.*` function sets + +### Type Hints and Documentation +- **Hover over any symbol** to see detailed type information +- **Built-in functions** show signatures and descriptions +- **Custom functions** display their definitions and parameters +- **Keywords and types** provide helpful documentation + +### Function References +- **F12**: Go to function definition +- **Shift+F12**: Find all references to a function +- **Ctrl+Shift+Space**: Show type information +- **Works with both built-in and custom functions** + +### Auto-completion +- **Context-aware suggestions** for functions, keywords, and types +- **Function signatures** in completion details +- **Built-in function documentation** in tooltips +- **Trigger characters**: `.`, `:`, `>` + +### Code Snippets +Use these snippets to speed up development: + +| Snippet | Description | Example | +|---------|-------------|---------| +| `func` | Function definition | `myFunc : x -> x + 1;` | +| `tfunc` | Typed function | `add : (x: Int, y: Int) -> Int -> x + y;` | +| `when` | When expression | `when x is 1 then "One" _ then "Other";` | +| `result` | Result handling | `when result is Ok v then v Err e then 0;` | +| `list` | List creation | `[1, 2, 3]` | +| `table` | Table creation | `{name: "value"}` | +| `map` | Map function | `map (x -> x * 2) list` | +| `filter` | Filter function | `filter (x -> x > 0) list` | +| `reduce` | Reduce function | `reduce (acc x -> acc + x) 0 list` | + +### Error Checking +- **Real-time validation** of syntax +- **Missing semicolon detection** +- **Basic type checking** for function calls +- **Pattern matching validation** + +## Commands + +The extension provides several commands accessible via the command palette: + +- **`Baba Yaga: Show Type Information`**: Display type info for current symbol +- **`Baba Yaga: Go to Definition`**: Navigate to function definition +- **`Baba Yaga: Find References`**: Find all references to current symbol +- **`Baba Yaga: Show Function Signature`**: Display function signature + +## Keybindings + +Default keybindings for Baba Yaga files: + +- **F12**: Go to definition +- **Shift+F12**: Find references +- **Ctrl+Shift+Space**: Show type information + +## Built-in Function Support + +The extension provides complete support for all Baba Yaga built-in functions: + +### IO Functions +- `io.out(value)` - Print to console +- `io.in()` - Read from console + +### String Functions +- `str.concat(str1, str2)` - String concatenation +- `str.split(str, delimiter)` - Split string +- `str.join(list, separator)` - Join list to string +- `str.length(str)` - String length +- `str.substring(str, start, end)` - Extract substring +- `str.replace(str, old, new)` - Replace substring +- `str.trim(str)` - Remove whitespace +- `str.upper(str)` - Convert to uppercase +- `str.lower(str)` - Convert to lowercase + +### Math Functions +- `math.abs(x)` - Absolute value +- `math.sign(x)` - Sign function +- `math.floor(x)`, `math.ceil(x)`, `math.round(x)`, `math.trunc(x)` - Rounding functions +- `math.min(x, y)`, `math.max(x, y)`, `math.clamp(x, lo, hi)` - Min/max functions +- `math.pow(x, y)`, `math.sqrt(x)`, `math.exp(x)`, `math.log(x)` - Power and log functions +- `math.sin(x)`, `math.cos(x)`, `math.tan(x)` - Trigonometric functions +- `math.asin(x)`, `math.acos(x)`, `math.atan(x)`, `math.atan2(y, x)` - Inverse trig functions +- `math.deg(x)`, `math.rad(x)` - Angle conversion +- `math.random()` - Random number (0-1) +- `math.randomInt(lo, hi)` - Random integer + +### List Functions +- `map(func, list)` - Apply function to each element +- `filter(pred, list)` - Filter by predicate +- `reduce(func, init, list)` - Fold to single value +- `append(list, item)` - Add item to end +- `set(table, key, value)` - Set table property +- `merge(table1, table2)` - Merge tables +- `shape(value)` - Get value metadata + +## Development + +### Building the Extension +```bash +cd dev/vscode +npm install +npm run compile +``` + +### Running Tests +```bash +npm test +``` + +### Debugging +1. Open the extension in VS Code +2. Press F5 to launch extension in development mode +3. Open a `.baba` file to test features + +### File Structure +``` +dev/vscode/ +├── src/ +│ └── extension.ts # Main extension code +├── syntaxes/ +│ └── baba-yaga.tmLanguage.json # TextMate grammar +├── snippets/ +│ └── baba-yaga.json # Code snippets +├── language-configuration.json # Language configuration +├── package.json # Extension manifest +├── tsconfig.json # TypeScript configuration +└── README.md # This file +``` + +## Troubleshooting + +### Extension Not Loading +1. Check VS Code version (requires 1.74.0+) +2. Verify TypeScript compilation: `npm run compile` +3. Check extension logs: Help > Toggle Developer Tools + +### Tree-sitter Not Working +1. Ensure `tree-sitter-baba-yaga` is installed +2. Check console for parser initialization errors +3. Extension falls back to basic features if Tree-sitter unavailable + +### Type Hints Not Showing +1. Verify `baba-yaga.enableTypeHints` is enabled +2. Hover over symbols, not whitespace +3. Check that the symbol is recognized + +### Auto-completion Issues +1. Ensure `baba-yaga.enableAutoComplete` is enabled +2. Type trigger characters (`.`, `:`, `>`) +3. Check for syntax errors in the file + +### Linting Errors (False Positives) +If you see JavaScript/TypeScript linting errors in `.baba` files (like missing semicolon warnings): + +1. **Install the extension properly** - Ensure the Baba Yaga extension is active +2. **Check file association** - Verify `.baba` files are recognized as "Baba Yaga" language +3. **Disable conflicting extensions** - Turn off ESLint, TypeScript, or other JavaScript linters +4. **Workspace settings** - Add this to your workspace `.vscode/settings.json`: + +```json +{ + "files.associations": { + "*.baba": "baba-yaga" + }, + "eslint.validate": [ + "javascript", + "javascriptreact", + "typescript", + "typescriptreact" + ], + "[baba-yaga]": { + "editor.formatOnSave": false, + "editor.codeActionsOnSave": {} + } +} +``` + +5. **Restart VS Code** - After making changes to settings + +**Note**: Baba Yaga doesn't use semicolons in the same way as JavaScript. The extension should handle this automatically, but if you see false linting errors, the above steps should resolve them. + +## Contributing + +To contribute to the extension: + +1. Fork the repository +2. Create a feature branch +3. Make your changes +4. Add tests if applicable +5. Submit a pull request + +## License + +This extension is provided under the same license as the main Baba Yaga project. diff --git a/js/baba-yaga/dev/vscode/baba-yaga-0.1.0.vsix b/js/baba-yaga/dev/vscode/baba-yaga-0.1.0.vsix new file mode 100644 index 0000000..9f93dc1 --- /dev/null +++ b/js/baba-yaga/dev/vscode/baba-yaga-0.1.0.vsix Binary files differdiff --git a/js/baba-yaga/dev/vscode/baba-yaga-1.0.0.vsix b/js/baba-yaga/dev/vscode/baba-yaga-1.0.0.vsix new file mode 100644 index 0000000..b178b60 --- /dev/null +++ b/js/baba-yaga/dev/vscode/baba-yaga-1.0.0.vsix Binary files differdiff --git a/js/baba-yaga/dev/vscode/baba-yaga-1.0.2.vsix b/js/baba-yaga/dev/vscode/baba-yaga-1.0.2.vsix new file mode 100644 index 0000000..03ba0b0 --- /dev/null +++ b/js/baba-yaga/dev/vscode/baba-yaga-1.0.2.vsix Binary files differdiff --git a/js/baba-yaga/dev/vscode/baba-yaga-1.0.3.vsix b/js/baba-yaga/dev/vscode/baba-yaga-1.0.3.vsix new file mode 100644 index 0000000..13f8b6e --- /dev/null +++ b/js/baba-yaga/dev/vscode/baba-yaga-1.0.3.vsix Binary files differdiff --git a/js/baba-yaga/dev/vscode/baba-yaga-1.0.4.vsix b/js/baba-yaga/dev/vscode/baba-yaga-1.0.4.vsix new file mode 100644 index 0000000..ae1b6d2 --- /dev/null +++ b/js/baba-yaga/dev/vscode/baba-yaga-1.0.4.vsix Binary files differdiff --git a/js/baba-yaga/dev/vscode/baba-yaga-1.1.1.vsix b/js/baba-yaga/dev/vscode/baba-yaga-1.1.1.vsix new file mode 100644 index 0000000..8666e79 --- /dev/null +++ b/js/baba-yaga/dev/vscode/baba-yaga-1.1.1.vsix Binary files differdiff --git a/js/baba-yaga/dev/vscode/extension.js b/js/baba-yaga/dev/vscode/extension.js new file mode 100644 index 0000000..f0be4f5 --- /dev/null +++ b/js/baba-yaga/dev/vscode/extension.js @@ -0,0 +1,896 @@ +const vscode = require('vscode'); + +// Type information for Baba Yaga +const builtinFunctions = new Map([ + ['io.out', { name: 'io.out', kind: 'function', signature: 'io.out(value: any) -> void', description: 'Print value to console' }], + ['io.in', { name: 'io.in', kind: 'function', signature: 'io.in() -> String', description: 'Read input from console' }], + ['map', { name: 'map', kind: 'function', signature: 'map(func: (T) -> U, list: [T]) -> [U]', description: 'Apply function to each element' }], + ['filter', { name: 'filter', kind: 'function', signature: 'filter(pred: (T) -> Bool, list: [T]) -> [T]', description: 'Filter list by predicate' }], + ['reduce', { name: 'reduce', kind: 'function', signature: 'reduce(func: (acc: T, item: T) -> T, init: T, list: [T]) -> T', description: 'Fold list to single value' }], + ['append', { name: 'append', kind: 'function', signature: 'append(list: [T], item: T) -> [T]', description: 'Add item to end of list' }], + ['set', { name: 'set', kind: 'function', signature: 'set(table: Table, key: String, value: any) -> Table', description: 'Set table property' }], + ['merge', { name: 'merge', kind: 'function', signature: 'merge(table1: Table, table2: Table) -> Table', description: 'Merge two tables' }], + ['shape', { name: 'shape', kind: 'function', signature: 'shape(value: any) -> Table', description: 'Get value metadata' }] +]); + +// String functions +const stringFunctions = ['concat', 'split', 'join', 'length', 'substring', 'replace', 'trim', 'upper', 'lower']; +stringFunctions.forEach(func => { + builtinFunctions.set(`str.${func}`, { + name: `str.${func}`, + kind: 'function', + signature: `str.${func}(...args) -> String`, + description: `String ${func} operation` + }); +}); + +// Math functions +const mathFunctions = ['abs', 'sign', 'floor', 'ceil', 'round', 'trunc', 'min', 'max', 'clamp', 'pow', 'sqrt', 'exp', 'log', 'sin', 'cos', 'tan', 'asin', 'acos', 'atan', 'atan2', 'deg', 'rad', 'random', 'randomInt']; +mathFunctions.forEach(func => { + builtinFunctions.set(`math.${func}`, { + name: `math.${func}`, + kind: 'function', + signature: `math.${func}(...args) -> Number`, + description: `Math ${func} operation` + }); +}); + +// Keywords +const keywords = new Map([ + ['when', { name: 'when', kind: 'keyword', description: 'Pattern matching expression' }], + ['then', { name: 'then', kind: 'keyword', description: 'Pattern match result' }], + ['is', { name: 'is', kind: 'keyword', description: 'Pattern match operator' }], + ['Ok', { name: 'Ok', kind: 'keyword', description: 'Success result constructor' }], + ['Err', { name: 'Err', kind: 'keyword', description: 'Error result constructor' }], + ['true', { name: 'true', kind: 'keyword', description: 'Boolean true value' }], + ['false', { name: 'false', kind: 'keyword', description: 'Boolean false value' }], + ['PI', { name: 'PI', kind: 'keyword', description: 'Mathematical constant π' }], + ['INFINITY', { name: 'INFINITY', kind: 'keyword', description: 'Positive infinity' }], + ['and', { name: 'and', kind: 'keyword', description: 'Logical AND operator' }], + ['or', { name: 'or', kind: 'keyword', description: 'Logical OR operator' }], + ['xor', { name: 'xor', kind: 'keyword', description: 'Logical XOR operator' }] +]); + +// Types +const types = new Map([ + ['Bool', { name: 'Bool', kind: 'type', description: 'Boolean type (true/false)' }], + ['Int', { name: 'Int', kind: 'type', description: 'Integer type' }], + ['Float', { name: 'Float', kind: 'type', description: 'Floating-point type' }], + ['String', { name: 'String', kind: 'type', description: 'String type' }], + ['List', { name: 'List', kind: 'type', description: 'List type [T]' }], + ['Table', { name: 'Table', kind: 'type', description: 'Table type {key: value}' }], + ['Result', { name: 'Result', kind: 'type', description: 'Result type (Ok T | Err String)' }], + ['Number', { name: 'Number', kind: 'type', description: 'Numeric supertype (Int | Float)' }] +]); + +// Helper functions +function findFunctionDefinition(document, functionName) { + const text = document.getText(); + const lines = text.split('\n'); + + for (let i = 0; i < lines.length; i++) { + const line = lines[i]; + const match = line.match(new RegExp(`\\b${functionName}\\s*:\\s*(.+?)\\s*->\\s*(.+?)\\s*;`)); + if (match) { + const signature = `${functionName} : ${match[1]} -> ${match[2]}`; + const startPos = document.positionAt(text.indexOf(line)); + const endPos = document.positionAt(text.indexOf(line) + line.length); + return { + signature, + range: new vscode.Range(startPos, endPos), + description: `Function defined at line ${i + 1}` + }; + } + } + + return null; +} + +// Helper function to check if position is in a Baba Yaga code block +function isInBabaYagaCodeBlock(document, position) { + const text = document.getText(); + const line = document.lineAt(position.line).text; + + // Check if we're in a markdown file + if (document.languageId === 'markdown') { + // Look for ```baba code blocks + const lines = text.split('\n'); + let inBabaBlock = false; + + for (let i = 0; i <= position.line; i++) { + const currentLine = lines[i]; + if (currentLine.trim().startsWith('```baba') || currentLine.trim().startsWith('```baba-yaga') || currentLine.trim().startsWith('```by')) { + inBabaBlock = true; + } else if (currentLine.trim() === '```' && inBabaBlock) { + inBabaBlock = false; + } + } + + return inBabaBlock; + } + + return document.languageId === 'baba-yaga'; +} + +// Hover Provider +class BabaYagaHoverProvider { + provideHover(document, position, token) { + // Only provide hover for Baba Yaga content + if (!isInBabaYagaCodeBlock(document, position)) { + return null; + } + + const wordRange = document.getWordRangeAtPosition(position); + if (!wordRange) return null; + + const word = document.getText(wordRange); + + // Check built-in functions + const builtin = builtinFunctions.get(word); + if (builtin) { + return new vscode.Hover([ + `**${builtin.name}**`, + `\`${builtin.signature}\``, + builtin.description || '' + ]); + } + + // Check keywords + const keyword = keywords.get(word); + if (keyword) { + return new vscode.Hover([ + `**${keyword.name}** (keyword)`, + keyword.description || '' + ]); + } + + // Check types + const type = types.get(word); + if (type) { + return new vscode.Hover([ + `**${type.name}** (type)`, + type.description || '' + ]); + } + + // Check for function definitions in the document + const functionDef = findFunctionDefinition(document, word); + if (functionDef) { + return new vscode.Hover([ + `**${word}** (function)`, + `\`${functionDef.signature}\``, + functionDef.description || '' + ]); + } + + return null; + } +} + +// Completion Provider +class BabaYagaCompletionProvider { + provideCompletionItems(document, position, token, context) { + // Only provide completion for Baba Yaga content + if (!isInBabaYagaCodeBlock(document, position)) { + return []; + } + + const items = []; + + // Add built-in functions + builtinFunctions.forEach((func, name) => { + const item = new vscode.CompletionItem(name, vscode.CompletionItemKind.Function); + item.detail = func.signature; + item.documentation = func.description; + items.push(item); + }); + + // Add keywords + keywords.forEach((keyword, name) => { + const item = new vscode.CompletionItem(name, vscode.CompletionItemKind.Keyword); + item.documentation = keyword.description; + items.push(item); + }); + + // Add types + types.forEach((type, name) => { + const item = new vscode.CompletionItem(name, vscode.CompletionItemKind.TypeParameter); + item.documentation = type.description; + items.push(item); + }); + + // Add operators + const operators = ['+', '-', '*', '/', '%', '=', '!=', '>', '<', '>=', '<=', '->', '..', ':', 'and', 'or', 'xor']; + operators.forEach(op => { + const item = new vscode.CompletionItem(op, vscode.CompletionItemKind.Operator); + items.push(item); + }); + + return items; + } +} + +// Definition Provider +class BabaYagaDefinitionProvider { + provideDefinition(document, position, token) { + // Only provide definition for Baba Yaga content + if (!isInBabaYagaCodeBlock(document, position)) { + return null; + } + + const wordRange = document.getWordRangeAtPosition(position); + if (!wordRange) return null; + + const word = document.getText(wordRange); + + // Find function definition in the document + const functionDef = findFunctionDefinition(document, word); + if (functionDef) { + return new vscode.Location(document.uri, functionDef.range); + } + + return null; + } +} + +// Reference Provider +class BabaYagaReferenceProvider { + provideReferences(document, position, context, token) { + // Only provide references for Baba Yaga content + if (!isInBabaYagaCodeBlock(document, position)) { + return []; + } + + const wordRange = document.getWordRangeAtPosition(position); + if (!wordRange) return null; + + const word = document.getText(wordRange); + const references = []; + + // Find all references in the document + const text = document.getText(); + const regex = new RegExp(`\\b${word}\\b`, 'g'); + let match; + + while ((match = regex.exec(text)) !== null) { + const startPos = document.positionAt(match.index); + const endPos = document.positionAt(match.index + match[0].length); + references.push(new vscode.Location(document.uri, new vscode.Range(startPos, endPos))); + } + + return references; + } +} + +// Diagnostic Provider +class BabaYagaDiagnosticProvider { + constructor() { + this.diagnosticCollection = vscode.languages.createDiagnosticCollection('baba-yaga'); + vscode.workspace.onDidChangeTextDocument(this.onDidChangeTextDocument.bind(this)); + } + + onDidChangeTextDocument(event) { + if (event.document.languageId === 'baba-yaga' || event.document.languageId === 'markdown' || event.document.languageId === 'baba' || event.document.languageId === 'by') { + this.updateDiagnostics(event.document); + } + } + + updateDiagnostics(document) { + // Disable automatic diagnostics to prevent false semicolon warnings + // Baba Yaga has different syntax rules than JavaScript/TypeScript + this.diagnosticCollection.set(document.uri, []); + } + + needsSemicolon(line) { + const trimmed = line.trim(); + + // Skip empty lines + if (!trimmed) return false; + + // Skip comment-only lines + if (trimmed.startsWith('//')) return false; + + // Extract code part before any inline comment + const commentIndex = trimmed.indexOf('//'); + const codePart = commentIndex >= 0 ? trimmed.substring(0, commentIndex).trim() : trimmed; + + // Skip if no actual code content + if (!codePart) return false; + + // Skip single identifiers or incomplete expressions (likely continuations) + if (codePart.match(/^\s*[a-zA-Z_][a-zA-Z0-9_]*\s*$/)) { + return false; + } + + // Lines that don't need semicolons + if (codePart.endsWith(';') || + codePart.endsWith('{') || + codePart.endsWith('}') || + codePart.endsWith('then') || // Pattern match continuations + codePart.endsWith('is')) { // Pattern match starts + return false; + } + + // Lines that are likely continuations (start with pattern keywords) + if (codePart.match(/^\s*(when|then|is|\d+|"[^"]*"|true|false|Ok|Err|_)\s/)) { + return false; + } + + // Skip arrow function definitions (they don't need semicolons) + if (codePart.includes('->')) return false; + + // Skip pattern matching expressions + if (codePart.includes('when') || codePart.includes('is') || codePart.includes('then')) return false; + + // Skip table/record definitions + if (codePart.match(/\{[^}]*\}/)) return false; + + // Skip list definitions + if (codePart.match(/\[[^\]]*\]/)) return false; + + // Skip function calls that might be part of larger expressions + if (codePart.match(/[a-zA-Z_][a-zA-Z0-9_]*\s*\(/)) return false; + + // This line needs a semicolon + return true; + } +} + +// Type Hints Provider - Shows type information in different modes +class BabaYagaTypeHintsProvider { + constructor(mode = 'above') { + this.mode = mode; + + // Inline decorations (after expressions) + this.inlineDecorations = vscode.window.createTextEditorDecorationType({ + after: { + margin: '0 0 0 1em', + color: new vscode.ThemeColor('editorCodeLens.foreground'), + fontStyle: 'italic', + fontSize: '0.9em' + } + }); + + // Above-line decorations (on line above expressions) - DISABLED + // this.aboveDecorations = vscode.window.createTextEditorDecorationType({ + // after: { + // contentText: '', + // color: new vscode.ThemeColor('editorCodeLens.foreground'), + // fontStyle: 'italic', + // fontSize: '1em', + // textDecoration: 'none; display: block; text-align: right; margin-right: 1em; line-height: 1.5;' + // } + // }); + } + + updateTypeHints(editor) { + if (!editor || !isInBabaYagaCodeBlock(editor.document, editor.selection.active)) { + return; + } + + // Clear previous decorations + editor.setDecorations(this.inlineDecorations, []); + // editor.setDecorations(this.aboveDecorations, []); + + if (this.mode === 'none') { + return; // No active type hints, only hover + } + + const document = editor.document; + const text = document.getText(); + const inlineDecorations = []; + // const aboveDecorations = []; // Not used when above mode is disabled + + // Parse function definitions to build type map + const functionTypes = new Map(); + const lines = text.split('\n'); + + for (let i = 0; i < lines.length; i++) { + const line = lines[i].trim(); + const funcMatch = line.match(/^(\w+)\s*:\s*(.+?)\s*->\s*(.+?)\s*;$/); + if (funcMatch) { + const [, funcName, params, returnType] = funcMatch; + functionTypes.set(funcName, { params, returnType }); + } + } + + // Find expressions to add type hints + for (let i = 0; i < lines.length; i++) { + const line = lines[i]; + + // Skip comments + if (line.trim().startsWith('//')) { + continue; + } + + // Function calls + const funcCallMatch = line.match(/\b(\w+)\s*\(/g); + if (funcCallMatch) { + funcCallMatch.forEach(match => { + const funcName = match.replace(/\s*\($/, ''); + const typeInfo = this.getTypeInfo(funcName, functionTypes); + if (typeInfo) { + const matchIndex = line.indexOf(match); + const lineStartIndex = text.split('\n').slice(0, i).join('\n').length + (i > 0 ? 1 : 0); + const startPos = document.positionAt(lineStartIndex + matchIndex); + const endPos = document.positionAt(lineStartIndex + matchIndex + match.length); + + if (this.mode === 'inline') { + inlineDecorations.push({ + range: new vscode.Range(startPos, endPos), + renderOptions: { + after: { + contentText: ` : ${typeInfo}`, + color: new vscode.ThemeColor('editorCodeLens.foreground'), + fontStyle: 'italic', + fontSize: '0.9em' + } + } + }); + } + // Above mode disabled - commented out + // } else if (this.mode === 'above') { + // const lineAbove = new vscode.Position(Math.max(0, startPos.line - 1), 0); + // aboveDecorations.push({ + // range: new vscode.Range(lineAbove, lineAbove), + // renderOptions: { + // after: { + // contentText: `\n${' '.repeat(Math.max(0, startPos.character - typeInfo.length - 3))} : ${typeInfo}`, + // color: new vscode.ThemeColor('editorCodeLens.foreground'), + // fontStyle: 'italic', + // fontSize: '0.8em' + // } + // } + // }); + // } + } + }); + } + + // Member access (str.func, math.func) + const memberMatch = line.match(/\b(\w+)\.(\w+)\s*\(/g); + if (memberMatch) { + memberMatch.forEach(match => { + const [, namespace, funcName] = match.match(/\b(\w+)\.(\w+)\s*\(/); + const typeInfo = this.getBuiltinTypeInfo(namespace, funcName); + if (typeInfo) { + const matchIndex = line.indexOf(match); + const lineStartIndex = text.split('\n').slice(0, i).join('\n').length + (i > 0 ? 1 : 0); + const startPos = document.positionAt(lineStartIndex + matchIndex); + const endPos = document.positionAt(lineStartIndex + matchIndex + match.length); + + if (this.mode === 'inline') { + inlineDecorations.push({ + range: new vscode.Range(startPos, endPos), + renderOptions: { + after: { + contentText: ` : ${typeInfo}`, + color: new vscode.ThemeColor('editorCodeLens.foreground'), + fontStyle: 'italic', + fontSize: '0.9em' + } + } + }); + } + // Above mode disabled - commented out + // else if (this.mode === 'above') { + // const lineAbove = new vscode.Position(Math.max(0, startPos.line - 1), 0); + // aboveDecorations.push({ + // range: new vscode.Range(lineAbove, lineAbove), + // renderOptions: { + // after: { + // contentText: `\n${' '.repeat(Math.max(0, startPos.character - typeInfo.length - 3))} : ${typeInfo}`, + // color: new vscode.ThemeColor('editorCodeLens.foreground'), + // fontStyle: 'italic', + // fontSize: '0.8em' + // } + // } + // }); + // } + } + }); + } + + // When expressions + if (line.includes('when') && line.includes('is')) { + const matchIndex = line.indexOf('when'); + const lineStartIndex = text.split('\n').slice(0, i).join('\n').length + (i > 0 ? 1 : 0); + const startPos = document.positionAt(lineStartIndex + matchIndex); + const endPos = document.positionAt(lineStartIndex + line.length); + + if (this.mode === 'inline') { + inlineDecorations.push({ + range: new vscode.Range(startPos, endPos), + renderOptions: { + after: { + contentText: ' : Pattern Matching', + color: new vscode.ThemeColor('editorCodeLens.foreground'), + fontStyle: 'italic', + fontSize: '0.9em' + } + } + }); + } + // Above mode disabled - commented out + // else if (this.mode === 'above') { + // const lineAbove = new vscode.Position(Math.max(0, startPos.line - 1), 0); + // aboveDecorations.push({ + // range: new vscode.Range(lineAbove, lineAbove), + // renderOptions: { + // after: { + // contentText: `\n${' '.repeat(Math.max(0, startPos.character - 18))} : Pattern Matching`, + // color: new vscode.ThemeColor('editorCodeLens.foreground'), + // fontStyle: 'italic', + // fontSize: '0.8em' + // } + // } + // }); + // } + } + + // Result constructors + if (line.includes('Ok') || line.includes('Err')) { + const okIndex = line.indexOf('Ok'); + const errIndex = line.indexOf('Err'); + const matchIndex = okIndex !== -1 ? okIndex : errIndex; + + if (matchIndex !== -1) { + const lineStartIndex = text.split('\n').slice(0, i).join('\n').length + (i > 0 ? 1 : 0); + const startPos = document.positionAt(lineStartIndex + matchIndex); + const endPos = document.positionAt(lineStartIndex + line.length); + + if (this.mode === 'inline') { + inlineDecorations.push({ + range: new vscode.Range(startPos, endPos), + renderOptions: { + after: { + contentText: ' : Result<T>', + color: new vscode.ThemeColor('editorCodeLens.foreground'), + fontStyle: 'italic', + fontSize: '0.9em' + } + } + }); + } + // Above mode disabled - commented out + // else if (this.mode === 'above') { + // const lineAbove = new vscode.Position(Math.max(0, startPos.line - 1), 0); + // aboveDecorations.push({ + // range: new vscode.Range(lineAbove, lineAbove), + // renderOptions: { + // after: { + // contentText: `\n${' '.repeat(Math.max(0, startPos.character - 12))} : Result<T>`, + // fontSize: '0.8em' + // } + // } + // }); + // } + } + } + } + + // Apply decorations based on mode + if (this.mode === 'inline') { + editor.setDecorations(this.inlineDecorations, inlineDecorations); + } + // if (this.mode === 'above') { + // editor.setDecorations(this.aboveDecorations, aboveDecorations); + // } + } + + getTypeInfo(funcName, functionTypes) { + // Check built-in functions first + const builtin = builtinFunctions.get(funcName); + if (builtin) { + return builtin.signature.split(' -> ')[1] || 'any'; + } + + // Check user-defined functions + const userFunc = functionTypes.get(funcName); + if (userFunc) { + return userFunc.returnType; + } + + return null; + } + + getBuiltinTypeInfo(namespace, funcName) { + const fullName = `${namespace}.${funcName}`; + const builtin = builtinFunctions.get(fullName); + if (builtin) { + return builtin.signature.split(' -> ')[1] || 'any'; + } + return null; + } + + dispose() { + this.inlineDecorations.dispose(); + // this.aboveDecorations.dispose(); + } +} + +// Command implementations +async function showTypeInfo() { + const editor = vscode.window.activeTextEditor; + if (!editor) return; + + const position = editor.selection.active; + + // Only work in Baba Yaga content + if (!isInBabaYagaCodeBlock(editor.document, position)) { + vscode.window.showInformationMessage('This command only works in Baba Yaga code blocks'); + return; + } + + const wordRange = editor.document.getWordRangeAtPosition(position); + if (!wordRange) return; + + const word = editor.document.getText(wordRange); + const type = builtinFunctions.get(word) || keywords.get(word) || types.get(word); + + if (type) { + vscode.window.showInformationMessage(`${word}: ${type.description || type.signature || type.name}`); + } +} + +async function goToDefinition() { + const editor = vscode.window.activeTextEditor; + if (!editor) return; + + const position = editor.selection.active; + + // Only work in Baba Yaga content + if (!isInBabaYagaCodeBlock(editor.document, position)) { + vscode.window.showInformationMessage('This command only works in Baba Yaga code blocks'); + return; + } + + const wordRange = editor.document.getWordRangeAtPosition(position); + if (!wordRange) return; + + const word = editor.document.getText(wordRange); + const functionDef = findFunctionDefinition(editor.document, word); + + if (functionDef) { + editor.selection = new vscode.Selection(functionDef.range.start, functionDef.range.end); + editor.revealRange(functionDef.range); + } +} + +async function findReferences() { + const editor = vscode.window.activeTextEditor; + if (!editor) return; + + const position = editor.selection.active; + + // Only work in Baba Yaga content + if (!isInBabaYagaCodeBlock(editor.document, position)) { + vscode.window.showInformationMessage('This command only works in Baba Yaga code blocks'); + return; + } + + const wordRange = editor.document.getWordRangeAtPosition(position); + if (!wordRange) return; + + const word = editor.document.getText(wordRange); + await vscode.commands.executeCommand('editor.action.referenceSearch.trigger'); +} + +async function showFunctionSignature() { + const editor = vscode.window.activeTextEditor; + if (!editor) return; + + const position = editor.selection.active; + + // Only work in Baba Yaga content + if (!isInBabaYagaCodeBlock(editor.document, position)) { + vscode.window.showInformationMessage('This command only works in Baba Yaga code blocks'); + return; + } + + const wordRange = editor.document.getWordRangeAtPosition(position); + if (!wordRange) return; + + const word = editor.document.getText(wordRange); + const builtin = builtinFunctions.get(word); + + if (builtin) { + vscode.window.showInformationMessage(`${word}: ${builtin.signature}`); + } +} + +// Baba Yaga Syntax Auto-Fix Rules +const syntaxFixRules = [ + // Rule 1: Function calls in comparisons + { + name: "Function Calls in Comparisons", + pattern: /(\w+(?:\.\w+)?(?:\s+[^><=!]+)*)\s*([><=!]=?)\s*([^;,\s]+)/g, + replacement: "($1) $2 $3", + description: "Wrap function calls in parentheses when used in comparisons" + }, + // Rule 2: Logical operators + { + name: "Logical Operators", + pattern: /([^;\s]+)\s+(and|or)\s+([^;\s]+)/g, + replacement: "($1) $2 ($3)", + description: "Wrap logical expressions in parentheses" + }, + // Rule 3: Complex arithmetic in comparisons + { + name: "Complex Arithmetic in Comparisons", + pattern: /([^;\s]*[\+\-\*\/][^;\s]*)\s*([><=!]=?)\s*([^;,\s]+)/g, + replacement: "($1) $2 $3", + description: "Wrap arithmetic expressions in parentheses when used in comparisons" + }, + // Rule 4: Nested function calls in comparisons + { + name: "Nested Function Calls in Comparisons", + pattern: /(\w+(?:\.\w+)?\s*\([^)]+\))\s*([><=!]=?)\s*([^;,\s]+)/g, + replacement: "($1) $2 $3", + description: "Wrap nested function calls in parentheses when used in comparisons" + } +]; + +// Function to apply syntax fixes +function applySyntaxFixes(editor) { + const document = editor.document; + const text = document.getText(); + let modifiedText = text; + let hasChanges = false; + + // Apply each rule in order + for (const rule of syntaxFixRules) { + const matches = [...modifiedText.matchAll(rule.pattern)]; + if (matches.length > 0) { + modifiedText = modifiedText.replace(rule.pattern, rule.replacement); + hasChanges = true; + } + } + + if (hasChanges) { + // Create edit + const fullRange = new vscode.Range( + document.positionAt(0), + document.positionAt(text.length) + ); + + const edit = new vscode.WorkspaceEdit(); + edit.replace(document.uri, fullRange, modifiedText); + + // Apply the edit + return vscode.workspace.applyEdit(edit); + } + + return Promise.resolve(false); +} + +// Function to show syntax fix suggestions +function showSyntaxFixSuggestions(editor) { + const document = editor.document; + const text = document.getText(); + const suggestions = []; + + for (const rule of syntaxFixRules) { + const matches = [...text.matchAll(rule.pattern)]; + if (matches.length > 0) { + suggestions.push({ + rule: rule.name, + count: matches.length, + description: rule.description, + examples: matches.slice(0, 3).map(match => match[0]) + }); + } + } + + if (suggestions.length > 0) { + const message = suggestions.map(s => + `${s.rule}: ${s.count} issue(s) found\n ${s.description}\n Examples: ${s.examples.join(', ')}` + ).join('\n\n'); + + vscode.window.showInformationMessage( + `Found ${suggestions.length} syntax issues that can be auto-fixed:\n\n${message}`, + { modal: true } + ); + } else { + vscode.window.showInformationMessage('No syntax issues found that can be auto-fixed.'); + } +} + +// Extension activation +function activate(context) { + console.log('Baba Yaga extension is now active!'); + + // Register commands + context.subscriptions.push( + vscode.commands.registerCommand('baba-yaga.showTypeInfo', showTypeInfo), + vscode.commands.registerCommand('baba-yaga.goToDefinition', goToDefinition), + vscode.commands.registerCommand('baba-yaga.findReferences', findReferences), + vscode.commands.registerCommand('baba-yaga.showFunctionSignature', showFunctionSignature), + vscode.commands.registerCommand('baba-yaga.autoFixSyntax', () => { + const editor = vscode.window.activeTextEditor; + if (editor && (editor.document.languageId === 'baba-yaga' || isInBabaYagaCodeBlock(editor.document, editor.selection.active))) { + applySyntaxFixes(editor).then(wasFixed => { + if (wasFixed) { + vscode.window.showInformationMessage('Syntax fixes applied successfully!'); + } else { + vscode.window.showInformationMessage('No syntax issues found to fix.'); + } + }); + } else { + vscode.window.showInformationMessage('This command only works in Baba Yaga code.'); + } + }), + vscode.commands.registerCommand('baba-yaga.showSyntaxIssues', () => { + const editor = vscode.window.activeTextEditor; + if (editor && (editor.document.languageId === 'baba-yaga' || isInBabaYagaCodeBlock(editor.document, editor.selection.active))) { + showSyntaxFixSuggestions(editor); + } else { + vscode.window.showInformationMessage('This command only works in Baba Yaga code.'); + } + }) + ); + + // Register language features + const config = vscode.workspace.getConfiguration('baba-yaga'); + + if (config.get('enableTypeHints')) { + context.subscriptions.push( + vscode.languages.registerHoverProvider('baba-yaga', new BabaYagaHoverProvider()), + vscode.languages.registerHoverProvider('markdown', new BabaYagaHoverProvider()), + vscode.languages.registerCompletionItemProvider('baba-yaga', new BabaYagaCompletionProvider(), '.', ':', '>'), + vscode.languages.registerCompletionItemProvider('markdown', new BabaYagaCompletionProvider(), '.', ':', '>') + ); + } + + if (config.get('enableFunctionReferences')) { + context.subscriptions.push( + vscode.languages.registerDefinitionProvider('baba-yaga', new BabaYagaDefinitionProvider()), + vscode.languages.registerDefinitionProvider('markdown', new BabaYagaDefinitionProvider()), + vscode.languages.registerReferenceProvider('baba-yaga', new BabaYagaReferenceProvider()), + vscode.languages.registerReferenceProvider('markdown', new BabaYagaReferenceProvider()) + ); + } + + if (config.get('enableErrorChecking')) { + context.subscriptions.push( + new BabaYagaDiagnosticProvider() + ); + } + + // Register type hints provider based on mode + const typeHintMode = config.get('typeHintMode'); + if (typeHintMode !== 'none') { + const typeHintsProvider = new BabaYagaTypeHintsProvider(typeHintMode); + context.subscriptions.push(typeHintsProvider); + + // Update type hints when text changes + vscode.workspace.onDidChangeTextDocument(event => { + if (event.document.languageId === 'baba-yaga' || event.document.languageId === 'markdown') { + const editor = vscode.window.activeTextEditor; + if (editor && editor.document === event.document) { + typeHintsProvider.updateTypeHints(editor); + } + } + }); + + // Update type hints when switching editors + vscode.window.onDidChangeActiveTextEditor(editor => { + if (editor && (editor.document.languageId === 'baba-yaga' || editor.document.languageId === 'markdown')) { + typeHintsProvider.updateTypeHints(editor); + } + }); + + // Initial update for current editor + const currentEditor = vscode.window.activeTextEditor; + if (currentEditor && (currentEditor.document.languageId === 'baba-yaga' || currentEditor.document.languageId === 'markdown')) { + typeHintsProvider.updateTypeHints(currentEditor); + } + } +} + +function deactivate() {} + +module.exports = { + activate, + deactivate +}; \ No newline at end of file diff --git a/js/baba-yaga/dev/vscode/install-and-test.sh b/js/baba-yaga/dev/vscode/install-and-test.sh new file mode 100755 index 0000000..bead137 --- /dev/null +++ b/js/baba-yaga/dev/vscode/install-and-test.sh @@ -0,0 +1,41 @@ +#!/bin/bash + +echo "🔧 Building and installing Baba Yaga VS Code extension..." + +# Build the extension +echo "📦 Packaging extension..." +npx vsce package --out baba-yaga-latest.vsix + +if [ $? -eq 0 ]; then + echo "✅ Extension packaged successfully" + + # Install the extension + echo "🚀 Installing extension in VS Code..." + code --install-extension baba-yaga-latest.vsix --force + + if [ $? -eq 0 ]; then + echo "✅ Extension installed successfully" + echo "" + echo "🧪 To test markdown highlighting:" + echo "1. Open MARKDOWN_TEST.md in VS Code" + echo "2. Check if Baba Yaga code blocks have syntax highlighting" + echo "3. If not, try 'Developer: Reload Window' (Ctrl+Shift+P)" + echo "" + echo "📋 Extension features:" + echo "- Syntax highlighting for .baba files" + echo "- Syntax highlighting in markdown code blocks" + echo "- Improved comment handling in diagnostics" + echo "- Support for typed curried functions" + echo "" + echo "🔍 Troubleshooting:" + echo "- Check extension is enabled in Extensions panel" + echo "- Verify markdown files show 'Markdown' in bottom right" + echo "- Try opening a .baba file to ensure basic highlighting works" + else + echo "❌ Failed to install extension" + exit 1 + fi +else + echo "❌ Failed to package extension" + exit 1 +fi \ No newline at end of file diff --git a/js/baba-yaga/dev/vscode/install.sh b/js/baba-yaga/dev/vscode/install.sh new file mode 100755 index 0000000..642dcab --- /dev/null +++ b/js/baba-yaga/dev/vscode/install.sh @@ -0,0 +1,47 @@ +#!/bin/bash + +# Baba Yaga VS Code Extension Installation Script + +echo "🚀 Installing Baba Yaga VS Code Extension..." + +# Check if Node.js is installed +if ! command -v node &> /dev/null; then + echo "❌ Node.js is required but not installed. Please install Node.js first." + exit 1 +fi + +# Check if npm is installed +if ! command -v npm &> /dev/null; then + echo "❌ npm is required but not installed. Please install npm first." + exit 1 +fi + +# Check if vsce is installed +if ! command -v vsce &> /dev/null; then + echo "📦 Installing vsce (VS Code Extension Manager)..." + npm install -g @vscode/vsce +fi + +# Install dependencies +echo "📦 Installing dependencies..." +npm install + +# Package the extension +echo "📦 Packaging extension..." +vsce package --allow-missing-repository + +# Check if packaging was successful +if [ $? -ne 0 ]; then + echo "❌ Extension packaging failed. Please check the errors above." + exit 1 +fi + +echo "✅ Extension packaged successfully!" +echo "" +echo "📋 To install the extension in VS Code:" +echo "1. Open VS Code" +echo "2. Go to Extensions (Ctrl+Shift+X)" +echo "3. Click the '...' menu and select 'Install from VSIX...'" +echo "4. Choose the generated 'baba-yaga-0.1.0.vsix' file" +echo "" +echo "🎉 Enjoy coding in Baba Yaga!" diff --git a/js/baba-yaga/dev/vscode/language-configuration.json b/js/baba-yaga/dev/vscode/language-configuration.json new file mode 100644 index 0000000..d80484d --- /dev/null +++ b/js/baba-yaga/dev/vscode/language-configuration.json @@ -0,0 +1,36 @@ +{ + "comments": { + "lineComment": "//", + "blockComment": ["/*", "*/"] + }, + "brackets": [ + ["{", "}"], + ["[", "]"], + ["(", ")"] + ], + "autoClosingPairs": [ + { "open": "{", "close": "}" }, + { "open": "[", "close": "]" }, + { "open": "(", "close": ")" }, + { "open": "\"", "close": "\"", "notIn": ["string"] }, + { "open": "'", "close": "'", "notIn": ["string"] } + ], + "surroundingPairs": [ + ["{", "}"], + ["[", "]"], + ["(", ")"], + ["\"", "\""], + ["'", "'"] + ], + "indentationRules": { + "increaseIndentPattern": "^(.*\\{[^}\"']*|.*\\([^)\"']*)$", + "decreaseIndentPattern": "^\\s*[})\\]]" + }, + "folding": { + "markers": { + "start": "^\\s*//\\s*#?region\\b", + "end": "^\\s*//\\s*#?endregion\\b" + } + }, + "validate": false +} diff --git a/js/baba-yaga/dev/vscode/out/extension.d.ts b/js/baba-yaga/dev/vscode/out/extension.d.ts new file mode 100644 index 0000000..12b5873 --- /dev/null +++ b/js/baba-yaga/dev/vscode/out/extension.d.ts @@ -0,0 +1,4 @@ +import * as vscode from 'vscode'; +export declare function activate(context: vscode.ExtensionContext): Promise<void>; +export declare function deactivate(): void; +//# sourceMappingURL=extension.d.ts.map \ No newline at end of file diff --git a/js/baba-yaga/dev/vscode/out/extension.d.ts.map b/js/baba-yaga/dev/vscode/out/extension.d.ts.map new file mode 100644 index 0000000..bfc4698 --- /dev/null +++ b/js/baba-yaga/dev/vscode/out/extension.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"extension.d.ts","sourceRoot":"","sources":["../src/extension.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,QAAQ,CAAC;AAMjC,wBAAsB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC,gBAAgB,iBA6C9D;AAED,wBAAgB,UAAU,SAAK"} \ No newline at end of file diff --git a/js/baba-yaga/dev/vscode/out/extension.js b/js/baba-yaga/dev/vscode/out/extension.js new file mode 100644 index 0000000..6e19efb --- /dev/null +++ b/js/baba-yaga/dev/vscode/out/extension.js @@ -0,0 +1,333 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); + __setModuleDefault(result, mod); + return result; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.deactivate = exports.activate = void 0; +const vscode = __importStar(require("vscode")); +// Tree-sitter parser for Baba Yaga (optional) +let parser; +let BabaYagaLanguage; +async function activate(context) { + console.log('Baba Yaga extension is now active!'); + // Initialize Tree-sitter parser (optional) + const enableTreeSitter = vscode.workspace.getConfiguration('baba-yaga').get('enableTreeSitter'); + if (enableTreeSitter) { + try { + const Parser = require('tree-sitter'); + Parser.init(); + // Note: tree-sitter-baba-yaga grammar would need to be built separately + // For now, we'll use basic features without Tree-sitter + console.log('Tree-sitter enabled but grammar not available'); + } + catch (error) { + console.warn('Tree-sitter not available, using basic features:', error); + } + } + // Register commands + context.subscriptions.push(vscode.commands.registerCommand('baba-yaga.showTypeInfo', showTypeInfo), vscode.commands.registerCommand('baba-yaga.goToDefinition', goToDefinition), vscode.commands.registerCommand('baba-yaga.findReferences', findReferences), vscode.commands.registerCommand('baba-yaga.showFunctionSignature', showFunctionSignature)); + // Register language features + if (vscode.workspace.getConfiguration('baba-yaga').get('enableTypeHints')) { + context.subscriptions.push(vscode.languages.registerHoverProvider('baba-yaga', new BabaYagaHoverProvider()), vscode.languages.registerCompletionItemProvider('baba-yaga', new BabaYagaCompletionProvider(), '.', ':', '>')); + } + if (vscode.workspace.getConfiguration('baba-yaga').get('enableFunctionReferences')) { + context.subscriptions.push(vscode.languages.registerDefinitionProvider('baba-yaga', new BabaYagaDefinitionProvider()), vscode.languages.registerReferenceProvider('baba-yaga', new BabaYagaReferenceProvider())); + } + if (vscode.workspace.getConfiguration('baba-yaga').get('enableErrorChecking')) { + context.subscriptions.push(vscode.languages.registerDiagnosticCollection('baba-yaga', new BabaYagaDiagnosticProvider())); + } +} +exports.activate = activate; +function deactivate() { } +exports.deactivate = deactivate; +// Built-in functions and their signatures +const builtinFunctions = new Map([ + ['io.out', { name: 'io.out', kind: 'function', signature: 'io.out(value: any) -> void', description: 'Print value to console' }], + ['io.in', { name: 'io.in', kind: 'function', signature: 'io.in() -> String', description: 'Read input from console' }], + ['map', { name: 'map', kind: 'function', signature: 'map(func: (T) -> U, list: [T]) -> [U]', description: 'Apply function to each element' }], + ['filter', { name: 'filter', kind: 'function', signature: 'filter(pred: (T) -> Bool, list: [T]) -> [T]', description: 'Filter list by predicate' }], + ['reduce', { name: 'reduce', kind: 'function', signature: 'reduce(func: (acc: T, item: T) -> T, init: T, list: [T]) -> T', description: 'Fold list to single value' }], + ['append', { name: 'append', kind: 'function', signature: 'append(list: [T], item: T) -> [T]', description: 'Add item to end of list' }], + ['set', { name: 'set', kind: 'function', signature: 'set(table: Table, key: String, value: any) -> Table', description: 'Set table property' }], + ['merge', { name: 'merge', kind: 'function', signature: 'merge(table1: Table, table2: Table) -> Table', description: 'Merge two tables' }], + ['shape', { name: 'shape', kind: 'function', signature: 'shape(value: any) -> Table', description: 'Get value metadata' }] +]); +// String functions +const stringFunctions = ['concat', 'split', 'join', 'length', 'substring', 'replace', 'trim', 'upper', 'lower']; +stringFunctions.forEach(func => { + builtinFunctions.set(`str.${func}`, { + name: `str.${func}`, + kind: 'function', + signature: `str.${func}(...args) -> String`, + description: `String ${func} operation` + }); +}); +// Math functions +const mathFunctions = ['abs', 'sign', 'floor', 'ceil', 'round', 'trunc', 'min', 'max', 'clamp', 'pow', 'sqrt', 'exp', 'log', 'sin', 'cos', 'tan', 'asin', 'acos', 'atan', 'atan2', 'deg', 'rad', 'random', 'randomInt']; +mathFunctions.forEach(func => { + builtinFunctions.set(`math.${func}`, { + name: `math.${func}`, + kind: 'function', + signature: `math.${func}(...args) -> Number`, + description: `Math ${func} operation` + }); +}); +// Keywords +const keywords = new Map([ + ['when', { name: 'when', kind: 'keyword', description: 'Pattern matching expression' }], + ['then', { name: 'then', kind: 'keyword', description: 'Pattern match result' }], + ['is', { name: 'is', kind: 'keyword', description: 'Pattern match operator' }], + ['Ok', { name: 'Ok', kind: 'keyword', description: 'Success result constructor' }], + ['Err', { name: 'Err', kind: 'keyword', description: 'Error result constructor' }], + ['true', { name: 'true', kind: 'keyword', description: 'Boolean true value' }], + ['false', { name: 'false', kind: 'keyword', description: 'Boolean false value' }], + ['PI', { name: 'PI', kind: 'keyword', description: 'Mathematical constant π' }], + ['INFINITY', { name: 'INFINITY', kind: 'keyword', description: 'Positive infinity' }], + ['and', { name: 'and', kind: 'keyword', description: 'Logical AND operator' }], + ['or', { name: 'or', kind: 'keyword', description: 'Logical OR operator' }], + ['xor', { name: 'xor', kind: 'keyword', description: 'Logical XOR operator' }] +]); +// Types +const types = new Map([ + ['Bool', { name: 'Bool', kind: 'type', description: 'Boolean type (true/false)' }], + ['Int', { name: 'Int', kind: 'type', description: 'Integer type' }], + ['Float', { name: 'Float', kind: 'type', description: 'Floating-point type' }], + ['String', { name: 'String', kind: 'type', description: 'String type' }], + ['List', { name: 'List', kind: 'type', description: 'List type [T]' }], + ['Table', { name: 'Table', kind: 'type', description: 'Table type {key: value}' }], + ['Result', { name: 'Result', kind: 'type', description: 'Result type (Ok T | Err String)' }], + ['Number', { name: 'Number', kind: 'type', description: 'Numeric supertype (Int | Float)' }] +]); +// Hover Provider +class BabaYagaHoverProvider { + provideHover(document, position, token) { + const wordRange = document.getWordRangeAtPosition(position); + if (!wordRange) + return null; + const word = document.getText(wordRange); + // Check built-in functions + const builtin = builtinFunctions.get(word); + if (builtin) { + return new vscode.Hover([ + `**${builtin.name}**`, + `\`${builtin.signature}\``, + builtin.description || '' + ]); + } + // Check keywords + const keyword = keywords.get(word); + if (keyword) { + return new vscode.Hover([ + `**${keyword.name}** (keyword)`, + keyword.description || '' + ]); + } + // Check types + const type = types.get(word); + if (type) { + return new vscode.Hover([ + `**${type.name}** (type)`, + type.description || '' + ]); + } + // Check for function definitions in the document + const functionDef = findFunctionDefinition(document, word); + if (functionDef) { + return new vscode.Hover([ + `**${word}** (function)`, + `\`${functionDef.signature}\``, + functionDef.description || '' + ]); + } + return null; + } +} +// Completion Provider +class BabaYagaCompletionProvider { + provideCompletionItems(document, position, token, context) { + const items = []; + // Add built-in functions + builtinFunctions.forEach((func, name) => { + const item = new vscode.CompletionItem(name, vscode.CompletionItemKind.Function); + item.detail = func.signature; + item.documentation = func.description; + items.push(item); + }); + // Add keywords + keywords.forEach((keyword, name) => { + const item = new vscode.CompletionItem(name, vscode.CompletionItemKind.Keyword); + item.documentation = keyword.description; + items.push(item); + }); + // Add types + types.forEach((type, name) => { + const item = new vscode.CompletionItem(name, vscode.CompletionItemKind.TypeParameter); + item.documentation = type.description; + items.push(item); + }); + // Add operators + const operators = ['+', '-', '*', '/', '%', '=', '!=', '>', '<', '>=', '<=', '->', '..', ':', 'and', 'or', 'xor']; + operators.forEach(op => { + const item = new vscode.CompletionItem(op, vscode.CompletionItemKind.Operator); + items.push(item); + }); + return items; + } +} +// Definition Provider +class BabaYagaDefinitionProvider { + provideDefinition(document, position, token) { + const wordRange = document.getWordRangeAtPosition(position); + if (!wordRange) + return null; + const word = document.getText(wordRange); + // Find function definition in the document + const functionDef = findFunctionDefinition(document, word); + if (functionDef) { + return new vscode.Location(document.uri, functionDef.range); + } + return null; + } +} +// Reference Provider +class BabaYagaReferenceProvider { + provideReferences(document, position, context, token) { + const wordRange = document.getWordRangeAtPosition(position); + if (!wordRange) + return null; + const word = document.getText(wordRange); + const references = []; + // Find all references in the document + const text = document.getText(); + const regex = new RegExp(`\\b${word}\\b`, 'g'); + let match; + while ((match = regex.exec(text)) !== null) { + const startPos = document.positionAt(match.index); + const endPos = document.positionAt(match.index + match[0].length); + references.push(new vscode.Location(document.uri, new vscode.Range(startPos, endPos))); + } + return references; + } +} +// Diagnostic Provider +class BabaYagaDiagnosticProvider { + constructor() { + this.diagnosticCollection = vscode.languages.createDiagnosticCollection('baba-yaga'); + vscode.workspace.onDidChangeTextDocument(this.onDidChangeTextDocument, this); + } + onDidChangeTextDocument(event) { + if (event.document.languageId === 'baba-yaga') { + this.updateDiagnostics(event.document); + } + } + updateDiagnostics(document) { + const diagnostics = []; + const text = document.getText(); + // Basic syntax checking + const lines = text.split('\n'); + lines.forEach((line, index) => { + // Check for missing semicolons + if (line.trim() && !line.trim().startsWith('//') && !line.trim().endsWith(';') && !line.trim().endsWith('{') && !line.trim().endsWith('}')) { + const range = new vscode.Range(index, line.length, index, line.length); + diagnostics.push(new vscode.Diagnostic(range, 'Missing semicolon', vscode.DiagnosticSeverity.Warning)); + } + }); + this.diagnosticCollection.set(document.uri, diagnostics); + } +} +// Helper functions +function findFunctionDefinition(document, functionName) { + const text = document.getText(); + const lines = text.split('\n'); + for (let i = 0; i < lines.length; i++) { + const line = lines[i]; + const match = line.match(new RegExp(`\\b${functionName}\\s*:\\s*(.+?)\\s*->\\s*(.+?)\\s*;`)); + if (match) { + const signature = `${functionName} : ${match[1]} -> ${match[2]}`; + const startPos = document.positionAt(text.indexOf(line)); + const endPos = document.positionAt(text.indexOf(line) + line.length); + return { + signature, + range: new vscode.Range(startPos, endPos), + description: `Function defined at line ${i + 1}` + }; + } + } + return null; +} +// Command implementations +async function showTypeInfo() { + const editor = vscode.window.activeTextEditor; + if (!editor || editor.document.languageId !== 'baba-yaga') + return; + const position = editor.selection.active; + const wordRange = editor.document.getWordRangeAtPosition(position); + if (!wordRange) + return; + const word = editor.document.getText(wordRange); + const type = builtinFunctions.get(word) || keywords.get(word) || types.get(word); + if (type) { + vscode.window.showInformationMessage(`${word}: ${type.description || type.signature || type.name}`); + } +} +async function goToDefinition() { + const editor = vscode.window.activeTextEditor; + if (!editor || editor.document.languageId !== 'baba-yaga') + return; + const position = editor.selection.active; + const wordRange = editor.document.getWordRangeAtPosition(position); + if (!wordRange) + return; + const word = editor.document.getText(wordRange); + const functionDef = findFunctionDefinition(editor.document, word); + if (functionDef) { + editor.selection = new vscode.Selection(functionDef.range.start, functionDef.range.end); + editor.revealRange(functionDef.range); + } +} +async function findReferences() { + const editor = vscode.window.activeTextEditor; + if (!editor || editor.document.languageId !== 'baba-yaga') + return; + const position = editor.selection.active; + const wordRange = editor.document.getWordRangeAtPosition(position); + if (!wordRange) + return; + const word = editor.document.getText(wordRange); + await vscode.commands.executeCommand('editor.action.referenceSearch.trigger'); +} +async function showFunctionSignature() { + const editor = vscode.window.activeTextEditor; + if (!editor || editor.document.languageId !== 'baba-yaga') + return; + const position = editor.selection.active; + const wordRange = editor.document.getWordRangeAtPosition(position); + if (!wordRange) + return; + const word = editor.document.getText(wordRange); + const builtin = builtinFunctions.get(word); + if (builtin) { + vscode.window.showInformationMessage(`${word}: ${builtin.signature}`); + } +} +//# sourceMappingURL=extension.js.map \ No newline at end of file diff --git a/js/baba-yaga/dev/vscode/out/extension.js.map b/js/baba-yaga/dev/vscode/out/extension.js.map new file mode 100644 index 0000000..103e6a3 --- /dev/null +++ b/js/baba-yaga/dev/vscode/out/extension.js.map @@ -0,0 +1 @@ +{"version":3,"file":"extension.js","sourceRoot":"","sources":["../src/extension.ts"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/js/baba-yaga/dev/vscode/package-lock.json b/js/baba-yaga/dev/vscode/package-lock.json new file mode 100644 index 0000000..61b7b00 --- /dev/null +++ b/js/baba-yaga/dev/vscode/package-lock.json @@ -0,0 +1,2249 @@ +{ + "name": "baba-yaga", + "version": "1.1.1", + "lockfileVersion": 3, + "requires": true, + "packages": { + "": { + "name": "baba-yaga", + "version": "1.1.1", + "license": "MIT", + "devDependencies": { + "@vscode/vsce": "^2.15.0" + }, + "engines": { + "vscode": "^1.74.0" + } + }, + "node_modules/@azure/abort-controller": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/@azure/abort-controller/-/abort-controller-2.1.2.tgz", + "integrity": "sha512-nBrLsEWm4J2u5LpAPjxADTlq3trDgVZZXHNKabeXZtpq3d3AbN/KGO82R87rdDz5/lYB024rtEf10/q0urNgsA==", + "dev": true, + "dependencies": { + "tslib": "^2.6.2" + }, + "engines": { + "node": ">=18.0.0" + } + }, + "node_modules/@azure/core-auth": { + "version": "1.10.0", + "resolved": "https://registry.npmjs.org/@azure/core-auth/-/core-auth-1.10.0.tgz", + "integrity": "sha512-88Djs5vBvGbHQHf5ZZcaoNHo6Y8BKZkt3cw2iuJIQzLEgH4Ox6Tm4hjFhbqOxyYsgIG/eJbFEHpxRIfEEWv5Ow==", + "dev": true, + "dependencies": { + "@azure/abort-controller": "^2.0.0", + "@azure/core-util": "^1.11.0", + "tslib": "^2.6.2" + }, + "engines": { + "node": ">=20.0.0" + } + }, + "node_modules/@azure/core-client": { + "version": "1.10.0", + "resolved": "https://registry.npmjs.org/@azure/core-client/-/core-client-1.10.0.tgz", + "integrity": "sha512-O4aP3CLFNodg8eTHXECaH3B3CjicfzkxVtnrfLkOq0XNP7TIECGfHpK/C6vADZkWP75wzmdBnsIA8ksuJMk18g==", + "dev": true, + "dependencies": { + "@azure/abort-controller": "^2.0.0", + "@azure/core-auth": "^1.4.0", + "@azure/core-rest-pipeline": "^1.20.0", + "@azure/core-tracing": "^1.0.0", + "@azure/core-util": "^1.6.1", + "@azure/logger": "^1.0.0", + "tslib": "^2.6.2" + }, + "engines": { + "node": ">=20.0.0" + } + }, + "node_modules/@azure/core-rest-pipeline": { + "version": "1.22.0", + "resolved": "https://registry.npmjs.org/@azure/core-rest-pipeline/-/core-rest-pipeline-1.22.0.tgz", + "integrity": "sha512-OKHmb3/Kpm06HypvB3g6Q3zJuvyXcpxDpCS1PnU8OV6AJgSFaee/covXBcPbWc6XDDxtEPlbi3EMQ6nUiPaQtw==", + "dev": true, + "dependencies": { + "@azure/abort-controller": "^2.0.0", + "@azure/core-auth": "^1.8.0", + "@azure/core-tracing": "^1.0.1", + "@azure/core-util": "^1.11.0", + "@azure/logger": "^1.0.0", + "@typespec/ts-http-runtime": "^0.3.0", + "tslib": "^2.6.2" + }, + "engines": { + "node": ">=20.0.0" + } + }, + "node_modules/@azure/core-tracing": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/@azure/core-tracing/-/core-tracing-1.3.0.tgz", + "integrity": "sha512-+XvmZLLWPe67WXNZo9Oc9CrPj/Tm8QnHR92fFAFdnbzwNdCH1h+7UdpaQgRSBsMY+oW1kHXNUZQLdZ1gHX3ROw==", + "dev": true, + "dependencies": { + "tslib": "^2.6.2" + }, + "engines": { + "node": ">=20.0.0" + } + }, + "node_modules/@azure/core-util": { + "version": "1.13.0", + "resolved": "https://registry.npmjs.org/@azure/core-util/-/core-util-1.13.0.tgz", + "integrity": "sha512-o0psW8QWQ58fq3i24Q1K2XfS/jYTxr7O1HRcyUE9bV9NttLU+kYOH82Ixj8DGlMTOWgxm1Sss2QAfKK5UkSPxw==", + "dev": true, + "dependencies": { + "@azure/abort-controller": "^2.0.0", + "@typespec/ts-http-runtime": "^0.3.0", + "tslib": "^2.6.2" + }, + "engines": { + "node": ">=20.0.0" + } + }, + "node_modules/@azure/identity": { + "version": "4.11.1", + "resolved": "https://registry.npmjs.org/@azure/identity/-/identity-4.11.1.tgz", + "integrity": "sha512-0ZdsLRaOyLxtCYgyuqyWqGU5XQ9gGnjxgfoNTt1pvELGkkUFrMATABZFIq8gusM7N1qbqpVtwLOhk0d/3kacLg==", + "dev": true, + "dependencies": { + "@azure/abort-controller": "^2.0.0", + "@azure/core-auth": "^1.9.0", + "@azure/core-client": "^1.9.2", + "@azure/core-rest-pipeline": "^1.17.0", + "@azure/core-tracing": "^1.0.0", + "@azure/core-util": "^1.11.0", + "@azure/logger": "^1.0.0", + "@azure/msal-browser": "^4.2.0", + "@azure/msal-node": "^3.5.0", + "open": "^10.1.0", + "tslib": "^2.2.0" + }, + "engines": { + "node": ">=20.0.0" + } + }, + "node_modules/@azure/logger": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/@azure/logger/-/logger-1.3.0.tgz", + "integrity": "sha512-fCqPIfOcLE+CGqGPd66c8bZpwAji98tZ4JI9i/mlTNTlsIWslCfpg48s/ypyLxZTump5sypjrKn2/kY7q8oAbA==", + "dev": true, + "dependencies": { + "@typespec/ts-http-runtime": "^0.3.0", + "tslib": "^2.6.2" + }, + "engines": { + "node": ">=20.0.0" + } + }, + "node_modules/@azure/msal-browser": { + "version": "4.19.0", + "resolved": "https://registry.npmjs.org/@azure/msal-browser/-/msal-browser-4.19.0.tgz", + "integrity": "sha512-g6Ea+sJmK7l5NUyrPhtD7DNj/tZcsr6VTNNLNuYs8yPvL3HNiIpO/0kzXntF9AqJ/6L+uz9aHmoT1x+RNq6zBQ==", + "dev": true, + "dependencies": { + "@azure/msal-common": "15.10.0" + }, + "engines": { + "node": ">=0.8.0" + } + }, + "node_modules/@azure/msal-common": { + "version": "15.10.0", + "resolved": "https://registry.npmjs.org/@azure/msal-common/-/msal-common-15.10.0.tgz", + "integrity": "sha512-+cGnma71NV3jzl6DdgdHsqriN4ZA7puBIzObSYCvcIVGMULGb2NrcOGV6IJxO06HoVRHFKijkxd9lcBvS063KQ==", + "dev": true, + "engines": { + "node": ">=0.8.0" + } + }, + "node_modules/@azure/msal-node": { + "version": "3.7.0", + "resolved": "https://registry.npmjs.org/@azure/msal-node/-/msal-node-3.7.0.tgz", + "integrity": "sha512-WsL11pT0hnoIr/4NCjG6uJswkmNA/9AgEre4mSQZS2e+ZPKUWwUdA5nCTnr4n1FMT1O5ezSEiJushnPW25Y+dA==", + "dev": true, + "dependencies": { + "@azure/msal-common": "15.10.0", + "jsonwebtoken": "^9.0.0", + "uuid": "^8.3.0" + }, + "engines": { + "node": ">=16" + } + }, + "node_modules/@typespec/ts-http-runtime": { + "version": "0.3.0", + "resolved": "https://registry.npmjs.org/@typespec/ts-http-runtime/-/ts-http-runtime-0.3.0.tgz", + "integrity": "sha512-sOx1PKSuFwnIl7z4RN0Ls7N9AQawmR9r66eI5rFCzLDIs8HTIYrIpH9QjYWoX0lkgGrkLxXhi4QnK7MizPRrIg==", + "dev": true, + "dependencies": { + "http-proxy-agent": "^7.0.0", + "https-proxy-agent": "^7.0.0", + "tslib": "^2.6.2" + }, + "engines": { + "node": ">=20.0.0" + } + }, + "node_modules/@vscode/vsce": { + "version": "2.32.0", + "resolved": "https://registry.npmjs.org/@vscode/vsce/-/vsce-2.32.0.tgz", + "integrity": "sha512-3EFJfsgrSftIqt3EtdRcAygy/OJ3hstyI1cDmIgkU9CFZW5C+3djr6mfosndCUqcVYuyjmxOK1xmFp/Bq7+NIg==", + "dev": true, + "dependencies": { + "@azure/identity": "^4.1.0", + "@vscode/vsce-sign": "^2.0.0", + "azure-devops-node-api": "^12.5.0", + "chalk": "^2.4.2", + "cheerio": "^1.0.0-rc.9", + "cockatiel": "^3.1.2", + "commander": "^6.2.1", + "form-data": "^4.0.0", + "glob": "^7.0.6", + "hosted-git-info": "^4.0.2", + "jsonc-parser": "^3.2.0", + "leven": "^3.1.0", + "markdown-it": "^12.3.2", + "mime": "^1.3.4", + "minimatch": "^3.0.3", + "parse-semver": "^1.1.1", + "read": "^1.0.7", + "semver": "^7.5.2", + "tmp": "^0.2.1", + "typed-rest-client": "^1.8.4", + "url-join": "^4.0.1", + "xml2js": "^0.5.0", + "yauzl": "^2.3.1", + "yazl": "^2.2.2" + }, + "bin": { + "vsce": "vsce" + }, + "engines": { + "node": ">= 16" + }, + "optionalDependencies": { + "keytar": "^7.7.0" + } + }, + "node_modules/@vscode/vsce-sign": { + "version": "2.0.6", + "resolved": "https://registry.npmjs.org/@vscode/vsce-sign/-/vsce-sign-2.0.6.tgz", + "integrity": "sha512-j9Ashk+uOWCDHYDxgGsqzKq5FXW9b9MW7QqOIYZ8IYpneJclWTBeHZz2DJCSKQgo+JAqNcaRRE1hzIx0dswqAw==", + "dev": true, + "hasInstallScript": true, + "optionalDependencies": { + "@vscode/vsce-sign-alpine-arm64": "2.0.5", + "@vscode/vsce-sign-alpine-x64": "2.0.5", + "@vscode/vsce-sign-darwin-arm64": "2.0.5", + "@vscode/vsce-sign-darwin-x64": "2.0.5", + "@vscode/vsce-sign-linux-arm": "2.0.5", + "@vscode/vsce-sign-linux-arm64": "2.0.5", + "@vscode/vsce-sign-linux-x64": "2.0.5", + "@vscode/vsce-sign-win32-arm64": "2.0.5", + "@vscode/vsce-sign-win32-x64": "2.0.5" + } + }, + "node_modules/@vscode/vsce-sign-alpine-arm64": { + "version": "2.0.5", + "resolved": "https://registry.npmjs.org/@vscode/vsce-sign-alpine-arm64/-/vsce-sign-alpine-arm64-2.0.5.tgz", + "integrity": "sha512-XVmnF40APwRPXSLYA28Ye+qWxB25KhSVpF2eZVtVOs6g7fkpOxsVnpRU1Bz2xG4ySI79IRuapDJoAQFkoOgfdQ==", + "cpu": [ + "arm64" + ], + "dev": true, + "optional": true, + "os": [ + "alpine" + ] + }, + "node_modules/@vscode/vsce-sign-alpine-x64": { + "version": "2.0.5", + "resolved": "https://registry.npmjs.org/@vscode/vsce-sign-alpine-x64/-/vsce-sign-alpine-x64-2.0.5.tgz", + "integrity": "sha512-JuxY3xcquRsOezKq6PEHwCgd1rh1GnhyH6urVEWUzWn1c1PC4EOoyffMD+zLZtFuZF5qR1I0+cqDRNKyPvpK7Q==", + "cpu": [ + "x64" + ], + "dev": true, + "optional": true, + "os": [ + "alpine" + ] + }, + "node_modules/@vscode/vsce-sign-darwin-arm64": { + "version": "2.0.5", + "resolved": "https://registry.npmjs.org/@vscode/vsce-sign-darwin-arm64/-/vsce-sign-darwin-arm64-2.0.5.tgz", + "integrity": "sha512-z2Q62bk0ptADFz8a0vtPvnm6vxpyP3hIEYMU+i1AWz263Pj8Mc38cm/4sjzxu+LIsAfhe9HzvYNS49lV+KsatQ==", + "cpu": [ + "arm64" + ], + "dev": true, + "optional": true, + "os": [ + "darwin" + ] + }, + "node_modules/@vscode/vsce-sign-darwin-x64": { + "version": "2.0.5", + "resolved": "https://registry.npmjs.org/@vscode/vsce-sign-darwin-x64/-/vsce-sign-darwin-x64-2.0.5.tgz", + "integrity": "sha512-ma9JDC7FJ16SuPXlLKkvOD2qLsmW/cKfqK4zzM2iJE1PbckF3BlR08lYqHV89gmuoTpYB55+z8Y5Fz4wEJBVDA==", + "cpu": [ + "x64" + ], + "dev": true, + "optional": true, + "os": [ + "darwin" + ] + }, + "node_modules/@vscode/vsce-sign-linux-arm": { + "version": "2.0.5", + "resolved": "https://registry.npmjs.org/@vscode/vsce-sign-linux-arm/-/vsce-sign-linux-arm-2.0.5.tgz", + "integrity": "sha512-cdCwtLGmvC1QVrkIsyzv01+o9eR+wodMJUZ9Ak3owhcGxPRB53/WvrDHAFYA6i8Oy232nuen1YqWeEohqBuSzA==", + "cpu": [ + "arm" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@vscode/vsce-sign-linux-arm64": { + "version": "2.0.5", + "resolved": "https://registry.npmjs.org/@vscode/vsce-sign-linux-arm64/-/vsce-sign-linux-arm64-2.0.5.tgz", + "integrity": "sha512-Hr1o0veBymg9SmkCqYnfaiUnes5YK6k/lKFA5MhNmiEN5fNqxyPUCdRZMFs3Ajtx2OFW4q3KuYVRwGA7jdLo7Q==", + "cpu": [ + "arm64" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@vscode/vsce-sign-linux-x64": { + "version": "2.0.5", + "resolved": "https://registry.npmjs.org/@vscode/vsce-sign-linux-x64/-/vsce-sign-linux-x64-2.0.5.tgz", + "integrity": "sha512-XLT0gfGMcxk6CMRLDkgqEPTyG8Oa0OFe1tPv2RVbphSOjFWJwZgK3TYWx39i/7gqpDHlax0AP6cgMygNJrA6zg==", + "cpu": [ + "x64" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@vscode/vsce-sign-win32-arm64": { + "version": "2.0.5", + "resolved": "https://registry.npmjs.org/@vscode/vsce-sign-win32-arm64/-/vsce-sign-win32-arm64-2.0.5.tgz", + "integrity": "sha512-hco8eaoTcvtmuPhavyCZhrk5QIcLiyAUhEso87ApAWDllG7djIrWiOCtqn48k4pHz+L8oCQlE0nwNHfcYcxOPw==", + "cpu": [ + "arm64" + ], + "dev": true, + "optional": true, + "os": [ + "win32" + ] + }, + "node_modules/@vscode/vsce-sign-win32-x64": { + "version": "2.0.5", + "resolved": "https://registry.npmjs.org/@vscode/vsce-sign-win32-x64/-/vsce-sign-win32-x64-2.0.5.tgz", + "integrity": "sha512-1ixKFGM2FwM+6kQS2ojfY3aAelICxjiCzeg4nTHpkeU1Tfs4RC+lVLrgq5NwcBC7ZLr6UfY3Ct3D6suPeOf7BQ==", + "cpu": [ + "x64" + ], + "dev": true, + "optional": true, + "os": [ + "win32" + ] + }, + "node_modules/agent-base": { + "version": "7.1.4", + "resolved": "https://registry.npmjs.org/agent-base/-/agent-base-7.1.4.tgz", + "integrity": "sha512-MnA+YT8fwfJPgBx3m60MNqakm30XOkyIoH1y6huTQvC0PwZG7ki8NacLBcrPbNoo8vEZy7Jpuk7+jMO+CUovTQ==", + "dev": true, + "engines": { + "node": ">= 14" + } + }, + "node_modules/ansi-styles": { + "version": "3.2.1", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz", + "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==", + "dev": true, + "dependencies": { + "color-convert": "^1.9.0" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/argparse": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz", + "integrity": "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==", + "dev": true + }, + "node_modules/asynckit": { + "version": "0.4.0", + "resolved": "https://registry.npmjs.org/asynckit/-/asynckit-0.4.0.tgz", + "integrity": "sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==", + "dev": true + }, + "node_modules/azure-devops-node-api": { + "version": "12.5.0", + "resolved": "https://registry.npmjs.org/azure-devops-node-api/-/azure-devops-node-api-12.5.0.tgz", + "integrity": "sha512-R5eFskGvOm3U/GzeAuxRkUsAl0hrAwGgWn6zAd2KrZmrEhWZVqLew4OOupbQlXUuojUzpGtq62SmdhJ06N88og==", + "dev": true, + "dependencies": { + "tunnel": "0.0.6", + "typed-rest-client": "^1.8.4" + } + }, + "node_modules/balanced-match": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz", + "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==", + "dev": true + }, + "node_modules/base64-js": { + "version": "1.5.1", + "resolved": "https://registry.npmjs.org/base64-js/-/base64-js-1.5.1.tgz", + "integrity": "sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA==", + "dev": true, + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/feross" + }, + { + "type": "patreon", + "url": "https://www.patreon.com/feross" + }, + { + "type": "consulting", + "url": "https://feross.org/support" + } + ], + "optional": true + }, + "node_modules/bl": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/bl/-/bl-4.1.0.tgz", + "integrity": "sha512-1W07cM9gS6DcLperZfFSj+bWLtaPGSOHWhPiGzXmvVJbRLdG82sH/Kn8EtW1VqWVA54AKf2h5k5BbnIbwF3h6w==", + "dev": true, + "optional": true, + "dependencies": { + "buffer": "^5.5.0", + "inherits": "^2.0.4", + "readable-stream": "^3.4.0" + } + }, + "node_modules/boolbase": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/boolbase/-/boolbase-1.0.0.tgz", + "integrity": "sha512-JZOSA7Mo9sNGB8+UjSgzdLtokWAky1zbztM3WRLCbZ70/3cTANmQmOdR7y2g+J0e2WXywy1yS468tY+IruqEww==", + "dev": true + }, + "node_modules/brace-expansion": { + "version": "1.1.12", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.12.tgz", + "integrity": "sha512-9T9UjW3r0UW5c1Q7GTwllptXwhvYmEzFhzMfZ9H7FQWt+uZePjZPjBP/W1ZEyZ1twGWom5/56TF4lPcqjnDHcg==", + "dev": true, + "dependencies": { + "balanced-match": "^1.0.0", + "concat-map": "0.0.1" + } + }, + "node_modules/buffer": { + "version": "5.7.1", + "resolved": "https://registry.npmjs.org/buffer/-/buffer-5.7.1.tgz", + "integrity": "sha512-EHcyIPBQ4BSGlvjB16k5KgAJ27CIsHY/2JBmCRReo48y9rQ3MaUzWX3KVlBa4U7MyX02HdVj0K7C3WaB3ju7FQ==", + "dev": true, + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/feross" + }, + { + "type": "patreon", + "url": "https://www.patreon.com/feross" + }, + { + "type": "consulting", + "url": "https://feross.org/support" + } + ], + "optional": true, + "dependencies": { + "base64-js": "^1.3.1", + "ieee754": "^1.1.13" + } + }, + "node_modules/buffer-crc32": { + "version": "0.2.13", + "resolved": "https://registry.npmjs.org/buffer-crc32/-/buffer-crc32-0.2.13.tgz", + "integrity": "sha512-VO9Ht/+p3SN7SKWqcrgEzjGbRSJYTx+Q1pTQC0wrWqHx0vpJraQ6GtHx8tvcg1rlK1byhU5gccxgOgj7B0TDkQ==", + "dev": true, + "engines": { + "node": "*" + } + }, + "node_modules/buffer-equal-constant-time": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/buffer-equal-constant-time/-/buffer-equal-constant-time-1.0.1.tgz", + "integrity": "sha512-zRpUiDwd/xk6ADqPMATG8vc9VPrkck7T07OIx0gnjmJAnHnTVXNQG3vfvWNuiZIkwu9KrKdA1iJKfsfTVxE6NA==", + "dev": true + }, + "node_modules/bundle-name": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/bundle-name/-/bundle-name-4.1.0.tgz", + "integrity": "sha512-tjwM5exMg6BGRI+kNmTntNsvdZS1X8BFYS6tnJ2hdH0kVxM6/eVZ2xy+FqStSWvYmtfFMDLIxurorHwDKfDz5Q==", + "dev": true, + "dependencies": { + "run-applescript": "^7.0.0" + }, + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/call-bind-apply-helpers": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/call-bind-apply-helpers/-/call-bind-apply-helpers-1.0.2.tgz", + "integrity": "sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ==", + "dev": true, + "dependencies": { + "es-errors": "^1.3.0", + "function-bind": "^1.1.2" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/call-bound": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/call-bound/-/call-bound-1.0.4.tgz", + "integrity": "sha512-+ys997U96po4Kx/ABpBCqhA9EuxJaQWDQg7295H4hBphv3IZg0boBKuwYpt4YXp6MZ5AmZQnU/tyMTlRpaSejg==", + "dev": true, + "dependencies": { + "call-bind-apply-helpers": "^1.0.2", + "get-intrinsic": "^1.3.0" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/chalk": { + "version": "2.4.2", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.2.tgz", + "integrity": "sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==", + "dev": true, + "dependencies": { + "ansi-styles": "^3.2.1", + "escape-string-regexp": "^1.0.5", + "supports-color": "^5.3.0" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/cheerio": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/cheerio/-/cheerio-1.1.2.tgz", + "integrity": "sha512-IkxPpb5rS/d1IiLbHMgfPuS0FgiWTtFIm/Nj+2woXDLTZ7fOT2eqzgYbdMlLweqlHbsZjxEChoVK+7iph7jyQg==", + "dev": true, + "dependencies": { + "cheerio-select": "^2.1.0", + "dom-serializer": "^2.0.0", + "domhandler": "^5.0.3", + "domutils": "^3.2.2", + "encoding-sniffer": "^0.2.1", + "htmlparser2": "^10.0.0", + "parse5": "^7.3.0", + "parse5-htmlparser2-tree-adapter": "^7.1.0", + "parse5-parser-stream": "^7.1.2", + "undici": "^7.12.0", + "whatwg-mimetype": "^4.0.0" + }, + "engines": { + "node": ">=20.18.1" + }, + "funding": { + "url": "https://github.com/cheeriojs/cheerio?sponsor=1" + } + }, + "node_modules/cheerio-select": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/cheerio-select/-/cheerio-select-2.1.0.tgz", + "integrity": "sha512-9v9kG0LvzrlcungtnJtpGNxY+fzECQKhK4EGJX2vByejiMX84MFNQw4UxPJl3bFbTMw+Dfs37XaIkCwTZfLh4g==", + "dev": true, + "dependencies": { + "boolbase": "^1.0.0", + "css-select": "^5.1.0", + "css-what": "^6.1.0", + "domelementtype": "^2.3.0", + "domhandler": "^5.0.3", + "domutils": "^3.0.1" + }, + "funding": { + "url": "https://github.com/sponsors/fb55" + } + }, + "node_modules/chownr": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/chownr/-/chownr-1.1.4.tgz", + "integrity": "sha512-jJ0bqzaylmJtVnNgzTeSOs8DPavpbYgEr/b0YL8/2GO3xJEhInFmhKMUnEJQjZumK7KXGFhUy89PrsJWlakBVg==", + "dev": true, + "optional": true + }, + "node_modules/cockatiel": { + "version": "3.2.1", + "resolved": "https://registry.npmjs.org/cockatiel/-/cockatiel-3.2.1.tgz", + "integrity": "sha512-gfrHV6ZPkquExvMh9IOkKsBzNDk6sDuZ6DdBGUBkvFnTCqCxzpuq48RySgP0AnaqQkw2zynOFj9yly6T1Q2G5Q==", + "dev": true, + "engines": { + "node": ">=16" + } + }, + "node_modules/color-convert": { + "version": "1.9.3", + "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-1.9.3.tgz", + "integrity": "sha512-QfAUtd+vFdAtFQcC8CCyYt1fYWxSqAiK2cSD6zDB8N3cpsEBAvRxp9zOGg6G/SHHJYAT88/az/IuDGALsNVbGg==", + "dev": true, + "dependencies": { + "color-name": "1.1.3" + } + }, + "node_modules/color-name": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.3.tgz", + "integrity": "sha512-72fSenhMw2HZMTVHeCA9KCmpEIbzWiQsjN+BHcBbS9vr1mtt+vJjPdksIBNUmKAW8TFUDPJK5SUU3QhE9NEXDw==", + "dev": true + }, + "node_modules/combined-stream": { + "version": "1.0.8", + "resolved": "https://registry.npmjs.org/combined-stream/-/combined-stream-1.0.8.tgz", + "integrity": "sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==", + "dev": true, + "dependencies": { + "delayed-stream": "~1.0.0" + }, + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/commander": { + "version": "6.2.1", + "resolved": "https://registry.npmjs.org/commander/-/commander-6.2.1.tgz", + "integrity": "sha512-U7VdrJFnJgo4xjrHpTzu0yrHPGImdsmD95ZlgYSEajAn2JKzDhDTPG9kBTefmObL2w/ngeZnilk+OV9CG3d7UA==", + "dev": true, + "engines": { + "node": ">= 6" + } + }, + "node_modules/concat-map": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz", + "integrity": "sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==", + "dev": true + }, + "node_modules/css-select": { + "version": "5.2.2", + "resolved": "https://registry.npmjs.org/css-select/-/css-select-5.2.2.tgz", + "integrity": "sha512-TizTzUddG/xYLA3NXodFM0fSbNizXjOKhqiQQwvhlspadZokn1KDy0NZFS0wuEubIYAV5/c1/lAr0TaaFXEXzw==", + "dev": true, + "dependencies": { + "boolbase": "^1.0.0", + "css-what": "^6.1.0", + "domhandler": "^5.0.2", + "domutils": "^3.0.1", + "nth-check": "^2.0.1" + }, + "funding": { + "url": "https://github.com/sponsors/fb55" + } + }, + "node_modules/css-what": { + "version": "6.2.2", + "resolved": "https://registry.npmjs.org/css-what/-/css-what-6.2.2.tgz", + "integrity": "sha512-u/O3vwbptzhMs3L1fQE82ZSLHQQfto5gyZzwteVIEyeaY5Fc7R4dapF/BvRoSYFeqfBk4m0V1Vafq5Pjv25wvA==", + "dev": true, + "engines": { + "node": ">= 6" + }, + "funding": { + "url": "https://github.com/sponsors/fb55" + } + }, + "node_modules/debug": { + "version": "4.4.1", + "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.1.tgz", + "integrity": "sha512-KcKCqiftBJcZr++7ykoDIEwSa3XWowTfNPo92BYxjXiyYEVrUQh2aLyhxBCwww+heortUFxEJYcRzosstTEBYQ==", + "dev": true, + "dependencies": { + "ms": "^2.1.3" + }, + "engines": { + "node": ">=6.0" + }, + "peerDependenciesMeta": { + "supports-color": { + "optional": true + } + } + }, + "node_modules/decompress-response": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/decompress-response/-/decompress-response-6.0.0.tgz", + "integrity": "sha512-aW35yZM6Bb/4oJlZncMH2LCoZtJXTRxES17vE3hoRiowU2kWHaJKFkSBDnDR+cm9J+9QhXmREyIfv0pji9ejCQ==", + "dev": true, + "optional": true, + "dependencies": { + "mimic-response": "^3.1.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/deep-extend": { + "version": "0.6.0", + "resolved": "https://registry.npmjs.org/deep-extend/-/deep-extend-0.6.0.tgz", + "integrity": "sha512-LOHxIOaPYdHlJRtCQfDIVZtfw/ufM8+rVj649RIHzcm/vGwQRXFt6OPqIFWsm2XEMrNIEtWR64sY1LEKD2vAOA==", + "dev": true, + "optional": true, + "engines": { + "node": ">=4.0.0" + } + }, + "node_modules/default-browser": { + "version": "5.2.1", + "resolved": "https://registry.npmjs.org/default-browser/-/default-browser-5.2.1.tgz", + "integrity": "sha512-WY/3TUME0x3KPYdRRxEJJvXRHV4PyPoUsxtZa78lwItwRQRHhd2U9xOscaT/YTf8uCXIAjeJOFBVEh/7FtD8Xg==", + "dev": true, + "dependencies": { + "bundle-name": "^4.1.0", + "default-browser-id": "^5.0.0" + }, + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/default-browser-id": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/default-browser-id/-/default-browser-id-5.0.0.tgz", + "integrity": "sha512-A6p/pu/6fyBcA1TRz/GqWYPViplrftcW2gZC9q79ngNCKAeR/X3gcEdXQHl4KNXV+3wgIJ1CPkJQ3IHM6lcsyA==", + "dev": true, + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/define-lazy-prop": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/define-lazy-prop/-/define-lazy-prop-3.0.0.tgz", + "integrity": "sha512-N+MeXYoqr3pOgn8xfyRPREN7gHakLYjhsHhWGT3fWAiL4IkAt0iDw14QiiEm2bE30c5XX5q0FtAA3CK5f9/BUg==", + "dev": true, + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/delayed-stream": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/delayed-stream/-/delayed-stream-1.0.0.tgz", + "integrity": "sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ==", + "dev": true, + "engines": { + "node": ">=0.4.0" + } + }, + "node_modules/detect-libc": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/detect-libc/-/detect-libc-2.0.4.tgz", + "integrity": "sha512-3UDv+G9CsCKO1WKMGw9fwq/SWJYbI0c5Y7LU1AXYoDdbhE2AHQ6N6Nb34sG8Fj7T5APy8qXDCKuuIHd1BR0tVA==", + "dev": true, + "optional": true, + "engines": { + "node": ">=8" + } + }, + "node_modules/dom-serializer": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/dom-serializer/-/dom-serializer-2.0.0.tgz", + "integrity": "sha512-wIkAryiqt/nV5EQKqQpo3SToSOV9J0DnbJqwK7Wv/Trc92zIAYZ4FlMu+JPFW1DfGFt81ZTCGgDEabffXeLyJg==", + "dev": true, + "dependencies": { + "domelementtype": "^2.3.0", + "domhandler": "^5.0.2", + "entities": "^4.2.0" + }, + "funding": { + "url": "https://github.com/cheeriojs/dom-serializer?sponsor=1" + } + }, + "node_modules/domelementtype": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/domelementtype/-/domelementtype-2.3.0.tgz", + "integrity": "sha512-OLETBj6w0OsagBwdXnPdN0cnMfF9opN69co+7ZrbfPGrdpPVNBUj02spi6B1N7wChLQiPn4CSH/zJvXw56gmHw==", + "dev": true, + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/fb55" + } + ] + }, + "node_modules/domhandler": { + "version": "5.0.3", + "resolved": "https://registry.npmjs.org/domhandler/-/domhandler-5.0.3.tgz", + "integrity": "sha512-cgwlv/1iFQiFnU96XXgROh8xTeetsnJiDsTc7TYCLFd9+/WNkIqPTxiM/8pSd8VIrhXGTf1Ny1q1hquVqDJB5w==", + "dev": true, + "dependencies": { + "domelementtype": "^2.3.0" + }, + "engines": { + "node": ">= 4" + }, + "funding": { + "url": "https://github.com/fb55/domhandler?sponsor=1" + } + }, + "node_modules/domutils": { + "version": "3.2.2", + "resolved": "https://registry.npmjs.org/domutils/-/domutils-3.2.2.tgz", + "integrity": "sha512-6kZKyUajlDuqlHKVX1w7gyslj9MPIXzIFiz/rGu35uC1wMi+kMhQwGhl4lt9unC9Vb9INnY9Z3/ZA3+FhASLaw==", + "dev": true, + "dependencies": { + "dom-serializer": "^2.0.0", + "domelementtype": "^2.3.0", + "domhandler": "^5.0.3" + }, + "funding": { + "url": "https://github.com/fb55/domutils?sponsor=1" + } + }, + "node_modules/dunder-proto": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/dunder-proto/-/dunder-proto-1.0.1.tgz", + "integrity": "sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A==", + "dev": true, + "dependencies": { + "call-bind-apply-helpers": "^1.0.1", + "es-errors": "^1.3.0", + "gopd": "^1.2.0" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/ecdsa-sig-formatter": { + "version": "1.0.11", + "resolved": "https://registry.npmjs.org/ecdsa-sig-formatter/-/ecdsa-sig-formatter-1.0.11.tgz", + "integrity": "sha512-nagl3RYrbNv6kQkeJIpt6NJZy8twLB/2vtz6yN9Z4vRKHN4/QZJIEbqohALSgwKdnksuY3k5Addp5lg8sVoVcQ==", + "dev": true, + "dependencies": { + "safe-buffer": "^5.0.1" + } + }, + "node_modules/encoding-sniffer": { + "version": "0.2.1", + "resolved": "https://registry.npmjs.org/encoding-sniffer/-/encoding-sniffer-0.2.1.tgz", + "integrity": "sha512-5gvq20T6vfpekVtqrYQsSCFZ1wEg5+wW0/QaZMWkFr6BqD3NfKs0rLCx4rrVlSWJeZb5NBJgVLswK/w2MWU+Gw==", + "dev": true, + "dependencies": { + "iconv-lite": "^0.6.3", + "whatwg-encoding": "^3.1.1" + }, + "funding": { + "url": "https://github.com/fb55/encoding-sniffer?sponsor=1" + } + }, + "node_modules/end-of-stream": { + "version": "1.4.5", + "resolved": "https://registry.npmjs.org/end-of-stream/-/end-of-stream-1.4.5.tgz", + "integrity": "sha512-ooEGc6HP26xXq/N+GCGOT0JKCLDGrq2bQUZrQ7gyrJiZANJ/8YDTxTpQBXGMn+WbIQXNVpyWymm7KYVICQnyOg==", + "dev": true, + "optional": true, + "dependencies": { + "once": "^1.4.0" + } + }, + "node_modules/entities": { + "version": "4.5.0", + "resolved": "https://registry.npmjs.org/entities/-/entities-4.5.0.tgz", + "integrity": "sha512-V0hjH4dGPh9Ao5p0MoRY6BVqtwCjhz6vI5LT8AJ55H+4g9/4vbHx1I54fS0XuclLhDHArPQCiMjDxjaL8fPxhw==", + "dev": true, + "engines": { + "node": ">=0.12" + }, + "funding": { + "url": "https://github.com/fb55/entities?sponsor=1" + } + }, + "node_modules/es-define-property": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/es-define-property/-/es-define-property-1.0.1.tgz", + "integrity": "sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g==", + "dev": true, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/es-errors": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/es-errors/-/es-errors-1.3.0.tgz", + "integrity": "sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==", + "dev": true, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/es-object-atoms": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/es-object-atoms/-/es-object-atoms-1.1.1.tgz", + "integrity": "sha512-FGgH2h8zKNim9ljj7dankFPcICIK9Cp5bm+c2gQSYePhpaG5+esrLODihIorn+Pe6FGJzWhXQotPv73jTaldXA==", + "dev": true, + "dependencies": { + "es-errors": "^1.3.0" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/es-set-tostringtag": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/es-set-tostringtag/-/es-set-tostringtag-2.1.0.tgz", + "integrity": "sha512-j6vWzfrGVfyXxge+O0x5sh6cvxAog0a/4Rdd2K36zCMV5eJ+/+tOAngRO8cODMNWbVRdVlmGZQL2YS3yR8bIUA==", + "dev": true, + "dependencies": { + "es-errors": "^1.3.0", + "get-intrinsic": "^1.2.6", + "has-tostringtag": "^1.0.2", + "hasown": "^2.0.2" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/escape-string-regexp": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz", + "integrity": "sha512-vbRorB5FUQWvla16U8R/qgaFIya2qGzwDrNmCZuYKrbdSUMG6I1ZCGQRefkRVhuOkIGVne7BQ35DSfo1qvJqFg==", + "dev": true, + "engines": { + "node": ">=0.8.0" + } + }, + "node_modules/expand-template": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/expand-template/-/expand-template-2.0.3.tgz", + "integrity": "sha512-XYfuKMvj4O35f/pOXLObndIRvyQ+/+6AhODh+OKWj9S9498pHHn/IMszH+gt0fBCRWMNfk1ZSp5x3AifmnI2vg==", + "dev": true, + "optional": true, + "engines": { + "node": ">=6" + } + }, + "node_modules/fd-slicer": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/fd-slicer/-/fd-slicer-1.1.0.tgz", + "integrity": "sha512-cE1qsB/VwyQozZ+q1dGxR8LBYNZeofhEdUNGSMbQD3Gw2lAzX9Zb3uIU6Ebc/Fmyjo9AWWfnn0AUCHqtevs/8g==", + "dev": true, + "dependencies": { + "pend": "~1.2.0" + } + }, + "node_modules/form-data": { + "version": "4.0.4", + "resolved": "https://registry.npmjs.org/form-data/-/form-data-4.0.4.tgz", + "integrity": "sha512-KrGhL9Q4zjj0kiUt5OO4Mr/A/jlI2jDYs5eHBpYHPcBEVSiipAvn2Ko2HnPe20rmcuuvMHNdZFp+4IlGTMF0Ow==", + "dev": true, + "dependencies": { + "asynckit": "^0.4.0", + "combined-stream": "^1.0.8", + "es-set-tostringtag": "^2.1.0", + "hasown": "^2.0.2", + "mime-types": "^2.1.12" + }, + "engines": { + "node": ">= 6" + } + }, + "node_modules/fs-constants": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/fs-constants/-/fs-constants-1.0.0.tgz", + "integrity": "sha512-y6OAwoSIf7FyjMIv94u+b5rdheZEjzR63GTyZJm5qh4Bi+2YgwLCcI/fPFZkL5PSixOt6ZNKm+w+Hfp/Bciwow==", + "dev": true, + "optional": true + }, + "node_modules/fs.realpath": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz", + "integrity": "sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw==", + "dev": true + }, + "node_modules/function-bind": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.2.tgz", + "integrity": "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==", + "dev": true, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/get-intrinsic": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.3.0.tgz", + "integrity": "sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ==", + "dev": true, + "dependencies": { + "call-bind-apply-helpers": "^1.0.2", + "es-define-property": "^1.0.1", + "es-errors": "^1.3.0", + "es-object-atoms": "^1.1.1", + "function-bind": "^1.1.2", + "get-proto": "^1.0.1", + "gopd": "^1.2.0", + "has-symbols": "^1.1.0", + "hasown": "^2.0.2", + "math-intrinsics": "^1.1.0" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/get-proto": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/get-proto/-/get-proto-1.0.1.tgz", + "integrity": "sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g==", + "dev": true, + "dependencies": { + "dunder-proto": "^1.0.1", + "es-object-atoms": "^1.0.0" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/github-from-package": { + "version": "0.0.0", + "resolved": "https://registry.npmjs.org/github-from-package/-/github-from-package-0.0.0.tgz", + "integrity": "sha512-SyHy3T1v2NUXn29OsWdxmK6RwHD+vkj3v8en8AOBZ1wBQ/hCAQ5bAQTD02kW4W9tUp/3Qh6J8r9EvntiyCmOOw==", + "dev": true, + "optional": true + }, + "node_modules/glob": { + "version": "7.2.3", + "resolved": "https://registry.npmjs.org/glob/-/glob-7.2.3.tgz", + "integrity": "sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==", + "deprecated": "Glob versions prior to v9 are no longer supported", + "dev": true, + "dependencies": { + "fs.realpath": "^1.0.0", + "inflight": "^1.0.4", + "inherits": "2", + "minimatch": "^3.1.1", + "once": "^1.3.0", + "path-is-absolute": "^1.0.0" + }, + "engines": { + "node": "*" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/gopd": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/gopd/-/gopd-1.2.0.tgz", + "integrity": "sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg==", + "dev": true, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/has-flag": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-3.0.0.tgz", + "integrity": "sha512-sKJf1+ceQBr4SMkvQnBDNDtf4TXpVhVGateu0t918bl30FnbE2m4vNLX+VWe/dpjlb+HugGYzW7uQXH98HPEYw==", + "dev": true, + "engines": { + "node": ">=4" + } + }, + "node_modules/has-symbols": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.1.0.tgz", + "integrity": "sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ==", + "dev": true, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/has-tostringtag": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/has-tostringtag/-/has-tostringtag-1.0.2.tgz", + "integrity": "sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw==", + "dev": true, + "dependencies": { + "has-symbols": "^1.0.3" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/hasown": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/hasown/-/hasown-2.0.2.tgz", + "integrity": "sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==", + "dev": true, + "dependencies": { + "function-bind": "^1.1.2" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/hosted-git-info": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/hosted-git-info/-/hosted-git-info-4.1.0.tgz", + "integrity": "sha512-kyCuEOWjJqZuDbRHzL8V93NzQhwIB71oFWSyzVo+KPZI+pnQPPxucdkrOZvkLRnrf5URsQM+IJ09Dw29cRALIA==", + "dev": true, + "dependencies": { + "lru-cache": "^6.0.0" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/htmlparser2": { + "version": "10.0.0", + "resolved": "https://registry.npmjs.org/htmlparser2/-/htmlparser2-10.0.0.tgz", + "integrity": "sha512-TwAZM+zE5Tq3lrEHvOlvwgj1XLWQCtaaibSN11Q+gGBAS7Y1uZSWwXXRe4iF6OXnaq1riyQAPFOBtYc77Mxq0g==", + "dev": true, + "funding": [ + "https://github.com/fb55/htmlparser2?sponsor=1", + { + "type": "github", + "url": "https://github.com/sponsors/fb55" + } + ], + "dependencies": { + "domelementtype": "^2.3.0", + "domhandler": "^5.0.3", + "domutils": "^3.2.1", + "entities": "^6.0.0" + } + }, + "node_modules/htmlparser2/node_modules/entities": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/entities/-/entities-6.0.1.tgz", + "integrity": "sha512-aN97NXWF6AWBTahfVOIrB/NShkzi5H7F9r1s9mD3cDj4Ko5f2qhhVoYMibXF7GlLveb/D2ioWay8lxI97Ven3g==", + "dev": true, + "engines": { + "node": ">=0.12" + }, + "funding": { + "url": "https://github.com/fb55/entities?sponsor=1" + } + }, + "node_modules/http-proxy-agent": { + "version": "7.0.2", + "resolved": "https://registry.npmjs.org/http-proxy-agent/-/http-proxy-agent-7.0.2.tgz", + "integrity": "sha512-T1gkAiYYDWYx3V5Bmyu7HcfcvL7mUrTWiM6yOfa3PIphViJ/gFPbvidQ+veqSOHci/PxBcDabeUNCzpOODJZig==", + "dev": true, + "dependencies": { + "agent-base": "^7.1.0", + "debug": "^4.3.4" + }, + "engines": { + "node": ">= 14" + } + }, + "node_modules/https-proxy-agent": { + "version": "7.0.6", + "resolved": "https://registry.npmjs.org/https-proxy-agent/-/https-proxy-agent-7.0.6.tgz", + "integrity": "sha512-vK9P5/iUfdl95AI+JVyUuIcVtd4ofvtrOr3HNtM2yxC9bnMbEdp3x01OhQNnjb8IJYi38VlTE3mBXwcfvywuSw==", + "dev": true, + "dependencies": { + "agent-base": "^7.1.2", + "debug": "4" + }, + "engines": { + "node": ">= 14" + } + }, + "node_modules/iconv-lite": { + "version": "0.6.3", + "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.6.3.tgz", + "integrity": "sha512-4fCk79wshMdzMp2rH06qWrJE4iolqLhCUH+OiuIgU++RB0+94NlDL81atO7GX55uUKueo0txHNtvEyI6D7WdMw==", + "dev": true, + "dependencies": { + "safer-buffer": ">= 2.1.2 < 3.0.0" + }, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/ieee754": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/ieee754/-/ieee754-1.2.1.tgz", + "integrity": "sha512-dcyqhDvX1C46lXZcVqCpK+FtMRQVdIMN6/Df5js2zouUsqG7I6sFxitIC+7KYK29KdXOLHdu9zL4sFnoVQnqaA==", + "dev": true, + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/feross" + }, + { + "type": "patreon", + "url": "https://www.patreon.com/feross" + }, + { + "type": "consulting", + "url": "https://feross.org/support" + } + ], + "optional": true + }, + "node_modules/inflight": { + "version": "1.0.6", + "resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz", + "integrity": "sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA==", + "deprecated": "This module is not supported, and leaks memory. Do not use it. Check out lru-cache if you want a good and tested way to coalesce async requests by a key value, which is much more comprehensive and powerful.", + "dev": true, + "dependencies": { + "once": "^1.3.0", + "wrappy": "1" + } + }, + "node_modules/inherits": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz", + "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==", + "dev": true + }, + "node_modules/ini": { + "version": "1.3.8", + "resolved": "https://registry.npmjs.org/ini/-/ini-1.3.8.tgz", + "integrity": "sha512-JV/yugV2uzW5iMRSiZAyDtQd+nxtUnjeLt0acNdw98kKLrvuRVyB80tsREOE7yvGVgalhZ6RNXCmEHkUKBKxew==", + "dev": true, + "optional": true + }, + "node_modules/is-docker": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/is-docker/-/is-docker-3.0.0.tgz", + "integrity": "sha512-eljcgEDlEns/7AXFosB5K/2nCM4P7FQPkGc/DWLy5rmFEWvZayGrik1d9/QIY5nJ4f9YsVvBkA6kJpHn9rISdQ==", + "dev": true, + "bin": { + "is-docker": "cli.js" + }, + "engines": { + "node": "^12.20.0 || ^14.13.1 || >=16.0.0" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/is-inside-container": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/is-inside-container/-/is-inside-container-1.0.0.tgz", + "integrity": "sha512-KIYLCCJghfHZxqjYBE7rEy0OBuTd5xCHS7tHVgvCLkx7StIoaxwNW3hCALgEUjFfeRk+MG/Qxmp/vtETEF3tRA==", + "dev": true, + "dependencies": { + "is-docker": "^3.0.0" + }, + "bin": { + "is-inside-container": "cli.js" + }, + "engines": { + "node": ">=14.16" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/is-wsl": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/is-wsl/-/is-wsl-3.1.0.tgz", + "integrity": "sha512-UcVfVfaK4Sc4m7X3dUSoHoozQGBEFeDC+zVo06t98xe8CzHSZZBekNXH+tu0NalHolcJ/QAGqS46Hef7QXBIMw==", + "dev": true, + "dependencies": { + "is-inside-container": "^1.0.0" + }, + "engines": { + "node": ">=16" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/jsonc-parser": { + "version": "3.3.1", + "resolved": "https://registry.npmjs.org/jsonc-parser/-/jsonc-parser-3.3.1.tgz", + "integrity": "sha512-HUgH65KyejrUFPvHFPbqOY0rsFip3Bo5wb4ngvdi1EpCYWUQDC5V+Y7mZws+DLkr4M//zQJoanu1SP+87Dv1oQ==", + "dev": true + }, + "node_modules/jsonwebtoken": { + "version": "9.0.2", + "resolved": "https://registry.npmjs.org/jsonwebtoken/-/jsonwebtoken-9.0.2.tgz", + "integrity": "sha512-PRp66vJ865SSqOlgqS8hujT5U4AOgMfhrwYIuIhfKaoSCZcirrmASQr8CX7cUg+RMih+hgznrjp99o+W4pJLHQ==", + "dev": true, + "dependencies": { + "jws": "^3.2.2", + "lodash.includes": "^4.3.0", + "lodash.isboolean": "^3.0.3", + "lodash.isinteger": "^4.0.4", + "lodash.isnumber": "^3.0.3", + "lodash.isplainobject": "^4.0.6", + "lodash.isstring": "^4.0.1", + "lodash.once": "^4.0.0", + "ms": "^2.1.1", + "semver": "^7.5.4" + }, + "engines": { + "node": ">=12", + "npm": ">=6" + } + }, + "node_modules/jwa": { + "version": "1.4.2", + "resolved": "https://registry.npmjs.org/jwa/-/jwa-1.4.2.tgz", + "integrity": "sha512-eeH5JO+21J78qMvTIDdBXidBd6nG2kZjg5Ohz/1fpa28Z4CcsWUzJ1ZZyFq/3z3N17aZy+ZuBoHljASbL1WfOw==", + "dev": true, + "dependencies": { + "buffer-equal-constant-time": "^1.0.1", + "ecdsa-sig-formatter": "1.0.11", + "safe-buffer": "^5.0.1" + } + }, + "node_modules/jws": { + "version": "3.2.2", + "resolved": "https://registry.npmjs.org/jws/-/jws-3.2.2.tgz", + "integrity": "sha512-YHlZCB6lMTllWDtSPHz/ZXTsi8S00usEV6v1tjq8tOUZzw7DpSDWVXjXDre6ed1w/pd495ODpHZYSdkRTsa0HA==", + "dev": true, + "dependencies": { + "jwa": "^1.4.1", + "safe-buffer": "^5.0.1" + } + }, + "node_modules/keytar": { + "version": "7.9.0", + "resolved": "https://registry.npmjs.org/keytar/-/keytar-7.9.0.tgz", + "integrity": "sha512-VPD8mtVtm5JNtA2AErl6Chp06JBfy7diFQ7TQQhdpWOl6MrCRB+eRbvAZUsbGQS9kiMq0coJsy0W0vHpDCkWsQ==", + "dev": true, + "hasInstallScript": true, + "optional": true, + "dependencies": { + "node-addon-api": "^4.3.0", + "prebuild-install": "^7.0.1" + } + }, + "node_modules/leven": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/leven/-/leven-3.1.0.tgz", + "integrity": "sha512-qsda+H8jTaUaN/x5vzW2rzc+8Rw4TAQ/4KjB46IwK5VH+IlVeeeje/EoZRpiXvIqjFgK84QffqPztGI3VBLG1A==", + "dev": true, + "engines": { + "node": ">=6" + } + }, + "node_modules/linkify-it": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/linkify-it/-/linkify-it-3.0.3.tgz", + "integrity": "sha512-ynTsyrFSdE5oZ/O9GEf00kPngmOfVwazR5GKDq6EYfhlpFug3J2zybX56a2PRRpc9P+FuSoGNAwjlbDs9jJBPQ==", + "dev": true, + "dependencies": { + "uc.micro": "^1.0.1" + } + }, + "node_modules/lodash.includes": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/lodash.includes/-/lodash.includes-4.3.0.tgz", + "integrity": "sha512-W3Bx6mdkRTGtlJISOvVD/lbqjTlPPUDTMnlXZFnVwi9NKJ6tiAk6LVdlhZMm17VZisqhKcgzpO5Wz91PCt5b0w==", + "dev": true + }, + "node_modules/lodash.isboolean": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/lodash.isboolean/-/lodash.isboolean-3.0.3.tgz", + "integrity": "sha512-Bz5mupy2SVbPHURB98VAcw+aHh4vRV5IPNhILUCsOzRmsTmSQ17jIuqopAentWoehktxGd9e/hbIXq980/1QJg==", + "dev": true + }, + "node_modules/lodash.isinteger": { + "version": "4.0.4", + "resolved": "https://registry.npmjs.org/lodash.isinteger/-/lodash.isinteger-4.0.4.tgz", + "integrity": "sha512-DBwtEWN2caHQ9/imiNeEA5ys1JoRtRfY3d7V9wkqtbycnAmTvRRmbHKDV4a0EYc678/dia0jrte4tjYwVBaZUA==", + "dev": true + }, + "node_modules/lodash.isnumber": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/lodash.isnumber/-/lodash.isnumber-3.0.3.tgz", + "integrity": "sha512-QYqzpfwO3/CWf3XP+Z+tkQsfaLL/EnUlXWVkIk5FUPc4sBdTehEqZONuyRt2P67PXAk+NXmTBcc97zw9t1FQrw==", + "dev": true + }, + "node_modules/lodash.isplainobject": { + "version": "4.0.6", + "resolved": "https://registry.npmjs.org/lodash.isplainobject/-/lodash.isplainobject-4.0.6.tgz", + "integrity": "sha512-oSXzaWypCMHkPC3NvBEaPHf0KsA5mvPrOPgQWDsbg8n7orZ290M0BmC/jgRZ4vcJ6DTAhjrsSYgdsW/F+MFOBA==", + "dev": true + }, + "node_modules/lodash.isstring": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/lodash.isstring/-/lodash.isstring-4.0.1.tgz", + "integrity": "sha512-0wJxfxH1wgO3GrbuP+dTTk7op+6L41QCXbGINEmD+ny/G/eCqGzxyCsh7159S+mgDDcoarnBw6PC1PS5+wUGgw==", + "dev": true + }, + "node_modules/lodash.once": { + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/lodash.once/-/lodash.once-4.1.1.tgz", + "integrity": "sha512-Sb487aTOCr9drQVL8pIxOzVhafOjZN9UU54hiN8PU3uAiSV7lx1yYNpbNmex2PK6dSJoNTSJUUswT651yww3Mg==", + "dev": true + }, + "node_modules/lru-cache": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-6.0.0.tgz", + "integrity": "sha512-Jo6dJ04CmSjuznwJSS3pUeWmd/H0ffTlkXXgwZi+eq1UCmqQwCh+eLsYOYCwY991i2Fah4h1BEMCx4qThGbsiA==", + "dev": true, + "dependencies": { + "yallist": "^4.0.0" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/markdown-it": { + "version": "12.3.2", + "resolved": "https://registry.npmjs.org/markdown-it/-/markdown-it-12.3.2.tgz", + "integrity": "sha512-TchMembfxfNVpHkbtriWltGWc+m3xszaRD0CZup7GFFhzIgQqxIfn3eGj1yZpfuflzPvfkt611B2Q/Bsk1YnGg==", + "dev": true, + "dependencies": { + "argparse": "^2.0.1", + "entities": "~2.1.0", + "linkify-it": "^3.0.1", + "mdurl": "^1.0.1", + "uc.micro": "^1.0.5" + }, + "bin": { + "markdown-it": "bin/markdown-it.js" + } + }, + "node_modules/markdown-it/node_modules/entities": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/entities/-/entities-2.1.0.tgz", + "integrity": "sha512-hCx1oky9PFrJ611mf0ifBLBRW8lUUVRlFolb5gWRfIELabBlbp9xZvrqZLZAs+NxFnbfQoeGd8wDkygjg7U85w==", + "dev": true, + "funding": { + "url": "https://github.com/fb55/entities?sponsor=1" + } + }, + "node_modules/math-intrinsics": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/math-intrinsics/-/math-intrinsics-1.1.0.tgz", + "integrity": "sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g==", + "dev": true, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/mdurl": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/mdurl/-/mdurl-1.0.1.tgz", + "integrity": "sha512-/sKlQJCBYVY9Ers9hqzKou4H6V5UWc/M59TH2dvkt+84itfnq7uFOMLpOiOS4ujvHP4etln18fmIxA5R5fll0g==", + "dev": true + }, + "node_modules/mime": { + "version": "1.6.0", + "resolved": "https://registry.npmjs.org/mime/-/mime-1.6.0.tgz", + "integrity": "sha512-x0Vn8spI+wuJ1O6S7gnbaQg8Pxh4NNHb7KSINmEWKiPE4RKOplvijn+NkmYmmRgP68mc70j2EbeTFRsrswaQeg==", + "dev": true, + "bin": { + "mime": "cli.js" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/mime-db": { + "version": "1.52.0", + "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.52.0.tgz", + "integrity": "sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==", + "dev": true, + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/mime-types": { + "version": "2.1.35", + "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.35.tgz", + "integrity": "sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==", + "dev": true, + "dependencies": { + "mime-db": "1.52.0" + }, + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/mimic-response": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/mimic-response/-/mimic-response-3.1.0.tgz", + "integrity": "sha512-z0yWI+4FDrrweS8Zmt4Ej5HdJmky15+L2e6Wgn3+iK5fWzb6T3fhNFq2+MeTRb064c6Wr4N/wv0DzQTjNzHNGQ==", + "dev": true, + "optional": true, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/minimatch": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz", + "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==", + "dev": true, + "dependencies": { + "brace-expansion": "^1.1.7" + }, + "engines": { + "node": "*" + } + }, + "node_modules/minimist": { + "version": "1.2.8", + "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.8.tgz", + "integrity": "sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA==", + "dev": true, + "optional": true, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/mkdirp-classic": { + "version": "0.5.3", + "resolved": "https://registry.npmjs.org/mkdirp-classic/-/mkdirp-classic-0.5.3.tgz", + "integrity": "sha512-gKLcREMhtuZRwRAfqP3RFW+TK4JqApVBtOIftVgjuABpAtpxhPGaDcfvbhNvD0B8iD1oUr/txX35NjcaY6Ns/A==", + "dev": true, + "optional": true + }, + "node_modules/ms": { + "version": "2.1.3", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz", + "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==", + "dev": true + }, + "node_modules/mute-stream": { + "version": "0.0.8", + "resolved": "https://registry.npmjs.org/mute-stream/-/mute-stream-0.0.8.tgz", + "integrity": "sha512-nnbWWOkoWyUsTjKrhgD0dcz22mdkSnpYqbEjIm2nhwhuxlSkpywJmBo8h0ZqJdkp73mb90SssHkN4rsRaBAfAA==", + "dev": true + }, + "node_modules/napi-build-utils": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/napi-build-utils/-/napi-build-utils-2.0.0.tgz", + "integrity": "sha512-GEbrYkbfF7MoNaoh2iGG84Mnf/WZfB0GdGEsM8wz7Expx/LlWf5U8t9nvJKXSp3qr5IsEbK04cBGhol/KwOsWA==", + "dev": true, + "optional": true + }, + "node_modules/node-abi": { + "version": "3.75.0", + "resolved": "https://registry.npmjs.org/node-abi/-/node-abi-3.75.0.tgz", + "integrity": "sha512-OhYaY5sDsIka7H7AtijtI9jwGYLyl29eQn/W623DiN/MIv5sUqc4g7BIDThX+gb7di9f6xK02nkp8sdfFWZLTg==", + "dev": true, + "optional": true, + "dependencies": { + "semver": "^7.3.5" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/node-addon-api": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/node-addon-api/-/node-addon-api-4.3.0.tgz", + "integrity": "sha512-73sE9+3UaLYYFmDsFZnqCInzPyh3MqIwZO9cw58yIqAZhONrrabrYyYe3TuIqtIiOuTXVhsGau8hcrhhwSsDIQ==", + "dev": true, + "optional": true + }, + "node_modules/nth-check": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/nth-check/-/nth-check-2.1.1.tgz", + "integrity": "sha512-lqjrjmaOoAnWfMmBPL+XNnynZh2+swxiX3WUE0s4yEHI6m+AwrK2UZOimIRl3X/4QctVqS8AiZjFqyOGrMXb/w==", + "dev": true, + "dependencies": { + "boolbase": "^1.0.0" + }, + "funding": { + "url": "https://github.com/fb55/nth-check?sponsor=1" + } + }, + "node_modules/object-inspect": { + "version": "1.13.4", + "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.13.4.tgz", + "integrity": "sha512-W67iLl4J2EXEGTbfeHCffrjDfitvLANg0UlX3wFUUSTx92KXRFegMHUVgSqE+wvhAbi4WqjGg9czysTV2Epbew==", + "dev": true, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/once": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz", + "integrity": "sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==", + "dev": true, + "dependencies": { + "wrappy": "1" + } + }, + "node_modules/open": { + "version": "10.2.0", + "resolved": "https://registry.npmjs.org/open/-/open-10.2.0.tgz", + "integrity": "sha512-YgBpdJHPyQ2UE5x+hlSXcnejzAvD0b22U2OuAP+8OnlJT+PjWPxtgmGqKKc+RgTM63U9gN0YzrYc71R2WT/hTA==", + "dev": true, + "dependencies": { + "default-browser": "^5.2.1", + "define-lazy-prop": "^3.0.0", + "is-inside-container": "^1.0.0", + "wsl-utils": "^0.1.0" + }, + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/parse-semver": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/parse-semver/-/parse-semver-1.1.1.tgz", + "integrity": "sha512-Eg1OuNntBMH0ojvEKSrvDSnwLmvVuUOSdylH/pSCPNMIspLlweJyIWXCE+k/5hm3cj/EBUYwmWkjhBALNP4LXQ==", + "dev": true, + "dependencies": { + "semver": "^5.1.0" + } + }, + "node_modules/parse-semver/node_modules/semver": { + "version": "5.7.2", + "resolved": "https://registry.npmjs.org/semver/-/semver-5.7.2.tgz", + "integrity": "sha512-cBznnQ9KjJqU67B52RMC65CMarK2600WFnbkcaiwWq3xy/5haFJlshgnpjovMVJ+Hff49d8GEn0b87C5pDQ10g==", + "dev": true, + "bin": { + "semver": "bin/semver" + } + }, + "node_modules/parse5": { + "version": "7.3.0", + "resolved": "https://registry.npmjs.org/parse5/-/parse5-7.3.0.tgz", + "integrity": "sha512-IInvU7fabl34qmi9gY8XOVxhYyMyuH2xUNpb2q8/Y+7552KlejkRvqvD19nMoUW/uQGGbqNpA6Tufu5FL5BZgw==", + "dev": true, + "dependencies": { + "entities": "^6.0.0" + }, + "funding": { + "url": "https://github.com/inikulin/parse5?sponsor=1" + } + }, + "node_modules/parse5-htmlparser2-tree-adapter": { + "version": "7.1.0", + "resolved": "https://registry.npmjs.org/parse5-htmlparser2-tree-adapter/-/parse5-htmlparser2-tree-adapter-7.1.0.tgz", + "integrity": "sha512-ruw5xyKs6lrpo9x9rCZqZZnIUntICjQAd0Wsmp396Ul9lN/h+ifgVV1x1gZHi8euej6wTfpqX8j+BFQxF0NS/g==", + "dev": true, + "dependencies": { + "domhandler": "^5.0.3", + "parse5": "^7.0.0" + }, + "funding": { + "url": "https://github.com/inikulin/parse5?sponsor=1" + } + }, + "node_modules/parse5-parser-stream": { + "version": "7.1.2", + "resolved": "https://registry.npmjs.org/parse5-parser-stream/-/parse5-parser-stream-7.1.2.tgz", + "integrity": "sha512-JyeQc9iwFLn5TbvvqACIF/VXG6abODeB3Fwmv/TGdLk2LfbWkaySGY72at4+Ty7EkPZj854u4CrICqNk2qIbow==", + "dev": true, + "dependencies": { + "parse5": "^7.0.0" + }, + "funding": { + "url": "https://github.com/inikulin/parse5?sponsor=1" + } + }, + "node_modules/parse5/node_modules/entities": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/entities/-/entities-6.0.1.tgz", + "integrity": "sha512-aN97NXWF6AWBTahfVOIrB/NShkzi5H7F9r1s9mD3cDj4Ko5f2qhhVoYMibXF7GlLveb/D2ioWay8lxI97Ven3g==", + "dev": true, + "engines": { + "node": ">=0.12" + }, + "funding": { + "url": "https://github.com/fb55/entities?sponsor=1" + } + }, + "node_modules/path-is-absolute": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz", + "integrity": "sha512-AVbw3UJ2e9bq64vSaS9Am0fje1Pa8pbGqTTsmXfaIiMpnr5DlDhfJOuLj9Sf95ZPVDAUerDfEk88MPmPe7UCQg==", + "dev": true, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/pend": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/pend/-/pend-1.2.0.tgz", + "integrity": "sha512-F3asv42UuXchdzt+xXqfW1OGlVBe+mxa2mqI0pg5yAHZPvFmY3Y6drSf/GQ1A86WgWEN9Kzh/WrgKa6iGcHXLg==", + "dev": true + }, + "node_modules/prebuild-install": { + "version": "7.1.3", + "resolved": "https://registry.npmjs.org/prebuild-install/-/prebuild-install-7.1.3.tgz", + "integrity": "sha512-8Mf2cbV7x1cXPUILADGI3wuhfqWvtiLA1iclTDbFRZkgRQS0NqsPZphna9V+HyTEadheuPmjaJMsbzKQFOzLug==", + "dev": true, + "optional": true, + "dependencies": { + "detect-libc": "^2.0.0", + "expand-template": "^2.0.3", + "github-from-package": "0.0.0", + "minimist": "^1.2.3", + "mkdirp-classic": "^0.5.3", + "napi-build-utils": "^2.0.0", + "node-abi": "^3.3.0", + "pump": "^3.0.0", + "rc": "^1.2.7", + "simple-get": "^4.0.0", + "tar-fs": "^2.0.0", + "tunnel-agent": "^0.6.0" + }, + "bin": { + "prebuild-install": "bin.js" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/pump": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/pump/-/pump-3.0.3.tgz", + "integrity": "sha512-todwxLMY7/heScKmntwQG8CXVkWUOdYxIvY2s0VWAAMh/nd8SoYiRaKjlr7+iCs984f2P8zvrfWcDDYVb73NfA==", + "dev": true, + "optional": true, + "dependencies": { + "end-of-stream": "^1.1.0", + "once": "^1.3.1" + } + }, + "node_modules/qs": { + "version": "6.14.0", + "resolved": "https://registry.npmjs.org/qs/-/qs-6.14.0.tgz", + "integrity": "sha512-YWWTjgABSKcvs/nWBi9PycY/JiPJqOD4JA6o9Sej2AtvSGarXxKC3OQSk4pAarbdQlKAh5D4FCQkJNkW+GAn3w==", + "dev": true, + "dependencies": { + "side-channel": "^1.1.0" + }, + "engines": { + "node": ">=0.6" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/rc": { + "version": "1.2.8", + "resolved": "https://registry.npmjs.org/rc/-/rc-1.2.8.tgz", + "integrity": "sha512-y3bGgqKj3QBdxLbLkomlohkvsA8gdAiUQlSBJnBhfn+BPxg4bc62d8TcBW15wavDfgexCgccckhcZvywyQYPOw==", + "dev": true, + "optional": true, + "dependencies": { + "deep-extend": "^0.6.0", + "ini": "~1.3.0", + "minimist": "^1.2.0", + "strip-json-comments": "~2.0.1" + }, + "bin": { + "rc": "cli.js" + } + }, + "node_modules/read": { + "version": "1.0.7", + "resolved": "https://registry.npmjs.org/read/-/read-1.0.7.tgz", + "integrity": "sha512-rSOKNYUmaxy0om1BNjMN4ezNT6VKK+2xF4GBhc81mkH7L60i6dp8qPYrkndNLT3QPphoII3maL9PVC9XmhHwVQ==", + "dev": true, + "dependencies": { + "mute-stream": "~0.0.4" + }, + "engines": { + "node": ">=0.8" + } + }, + "node_modules/readable-stream": { + "version": "3.6.2", + "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-3.6.2.tgz", + "integrity": "sha512-9u/sniCrY3D5WdsERHzHE4G2YCXqoG5FTHUiCC4SIbr6XcLZBY05ya9EKjYek9O5xOAwjGq+1JdGBAS7Q9ScoA==", + "dev": true, + "optional": true, + "dependencies": { + "inherits": "^2.0.3", + "string_decoder": "^1.1.1", + "util-deprecate": "^1.0.1" + }, + "engines": { + "node": ">= 6" + } + }, + "node_modules/run-applescript": { + "version": "7.0.0", + "resolved": "https://registry.npmjs.org/run-applescript/-/run-applescript-7.0.0.tgz", + "integrity": "sha512-9by4Ij99JUr/MCFBUkDKLWK3G9HVXmabKz9U5MlIAIuvuzkiOicRYs8XJLxX+xahD+mLiiCYDqF9dKAgtzKP1A==", + "dev": true, + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/safe-buffer": { + "version": "5.2.1", + "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz", + "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==", + "dev": true, + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/feross" + }, + { + "type": "patreon", + "url": "https://www.patreon.com/feross" + }, + { + "type": "consulting", + "url": "https://feross.org/support" + } + ] + }, + "node_modules/safer-buffer": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz", + "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==", + "dev": true + }, + "node_modules/sax": { + "version": "1.4.1", + "resolved": "https://registry.npmjs.org/sax/-/sax-1.4.1.tgz", + "integrity": "sha512-+aWOz7yVScEGoKNd4PA10LZ8sk0A/z5+nXQG5giUO5rprX9jgYsTdov9qCchZiPIZezbZH+jRut8nPodFAX4Jg==", + "dev": true + }, + "node_modules/semver": { + "version": "7.7.2", + "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.2.tgz", + "integrity": "sha512-RF0Fw+rO5AMf9MAyaRXI4AV0Ulj5lMHqVxxdSgiVbixSCXoEmmX/jk0CuJw4+3SqroYO9VoUh+HcuJivvtJemA==", + "dev": true, + "bin": { + "semver": "bin/semver.js" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/side-channel": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/side-channel/-/side-channel-1.1.0.tgz", + "integrity": "sha512-ZX99e6tRweoUXqR+VBrslhda51Nh5MTQwou5tnUDgbtyM0dBgmhEDtWGP/xbKn6hqfPRHujUNwz5fy/wbbhnpw==", + "dev": true, + "dependencies": { + "es-errors": "^1.3.0", + "object-inspect": "^1.13.3", + "side-channel-list": "^1.0.0", + "side-channel-map": "^1.0.1", + "side-channel-weakmap": "^1.0.2" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/side-channel-list": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/side-channel-list/-/side-channel-list-1.0.0.tgz", + "integrity": "sha512-FCLHtRD/gnpCiCHEiJLOwdmFP+wzCmDEkc9y7NsYxeF4u7Btsn1ZuwgwJGxImImHicJArLP4R0yX4c2KCrMrTA==", + "dev": true, + "dependencies": { + "es-errors": "^1.3.0", + "object-inspect": "^1.13.3" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/side-channel-map": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/side-channel-map/-/side-channel-map-1.0.1.tgz", + "integrity": "sha512-VCjCNfgMsby3tTdo02nbjtM/ewra6jPHmpThenkTYh8pG9ucZ/1P8So4u4FGBek/BjpOVsDCMoLA/iuBKIFXRA==", + "dev": true, + "dependencies": { + "call-bound": "^1.0.2", + "es-errors": "^1.3.0", + "get-intrinsic": "^1.2.5", + "object-inspect": "^1.13.3" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/side-channel-weakmap": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/side-channel-weakmap/-/side-channel-weakmap-1.0.2.tgz", + "integrity": "sha512-WPS/HvHQTYnHisLo9McqBHOJk2FkHO/tlpvldyrnem4aeQp4hai3gythswg6p01oSoTl58rcpiFAjF2br2Ak2A==", + "dev": true, + "dependencies": { + "call-bound": "^1.0.2", + "es-errors": "^1.3.0", + "get-intrinsic": "^1.2.5", + "object-inspect": "^1.13.3", + "side-channel-map": "^1.0.1" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/simple-concat": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/simple-concat/-/simple-concat-1.0.1.tgz", + "integrity": "sha512-cSFtAPtRhljv69IK0hTVZQ+OfE9nePi/rtJmw5UjHeVyVroEqJXP1sFztKUy1qU+xvz3u/sfYJLa947b7nAN2Q==", + "dev": true, + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/feross" + }, + { + "type": "patreon", + "url": "https://www.patreon.com/feross" + }, + { + "type": "consulting", + "url": "https://feross.org/support" + } + ], + "optional": true + }, + "node_modules/simple-get": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/simple-get/-/simple-get-4.0.1.tgz", + "integrity": "sha512-brv7p5WgH0jmQJr1ZDDfKDOSeWWg+OVypG99A/5vYGPqJ6pxiaHLy8nxtFjBA7oMa01ebA9gfh1uMCFqOuXxvA==", + "dev": true, + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/feross" + }, + { + "type": "patreon", + "url": "https://www.patreon.com/feross" + }, + { + "type": "consulting", + "url": "https://feross.org/support" + } + ], + "optional": true, + "dependencies": { + "decompress-response": "^6.0.0", + "once": "^1.3.1", + "simple-concat": "^1.0.0" + } + }, + "node_modules/string_decoder": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.3.0.tgz", + "integrity": "sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA==", + "dev": true, + "optional": true, + "dependencies": { + "safe-buffer": "~5.2.0" + } + }, + "node_modules/strip-json-comments": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-2.0.1.tgz", + "integrity": "sha512-4gB8na07fecVVkOI6Rs4e7T6NOTki5EmL7TUduTs6bu3EdnSycntVJ4re8kgZA+wx9IueI2Y11bfbgwtzuE0KQ==", + "dev": true, + "optional": true, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/supports-color": { + "version": "5.5.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.5.0.tgz", + "integrity": "sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==", + "dev": true, + "dependencies": { + "has-flag": "^3.0.0" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/tar-fs": { + "version": "2.1.3", + "resolved": "https://registry.npmjs.org/tar-fs/-/tar-fs-2.1.3.tgz", + "integrity": "sha512-090nwYJDmlhwFwEW3QQl+vaNnxsO2yVsd45eTKRBzSzu+hlb1w2K9inVq5b0ngXuLVqQ4ApvsUHHnu/zQNkWAg==", + "dev": true, + "optional": true, + "dependencies": { + "chownr": "^1.1.1", + "mkdirp-classic": "^0.5.2", + "pump": "^3.0.0", + "tar-stream": "^2.1.4" + } + }, + "node_modules/tar-stream": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/tar-stream/-/tar-stream-2.2.0.tgz", + "integrity": "sha512-ujeqbceABgwMZxEJnk2HDY2DlnUZ+9oEcb1KzTVfYHio0UE6dG71n60d8D2I4qNvleWrrXpmjpt7vZeF1LnMZQ==", + "dev": true, + "optional": true, + "dependencies": { + "bl": "^4.0.3", + "end-of-stream": "^1.4.1", + "fs-constants": "^1.0.0", + "inherits": "^2.0.3", + "readable-stream": "^3.1.1" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/tmp": { + "version": "0.2.4", + "resolved": "https://registry.npmjs.org/tmp/-/tmp-0.2.4.tgz", + "integrity": "sha512-UdiSoX6ypifLmrfQ/XfiawN6hkjSBpCjhKxxZcWlUUmoXLaCKQU0bx4HF/tdDK2uzRuchf1txGvrWBzYREssoQ==", + "dev": true, + "engines": { + "node": ">=14.14" + } + }, + "node_modules/tslib": { + "version": "2.8.1", + "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz", + "integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==", + "dev": true + }, + "node_modules/tunnel": { + "version": "0.0.6", + "resolved": "https://registry.npmjs.org/tunnel/-/tunnel-0.0.6.tgz", + "integrity": "sha512-1h/Lnq9yajKY2PEbBadPXj3VxsDDu844OnaAo52UVmIzIvwwtBPIuNvkjuzBlTWpfJyUbG3ez0KSBibQkj4ojg==", + "dev": true, + "engines": { + "node": ">=0.6.11 <=0.7.0 || >=0.7.3" + } + }, + "node_modules/tunnel-agent": { + "version": "0.6.0", + "resolved": "https://registry.npmjs.org/tunnel-agent/-/tunnel-agent-0.6.0.tgz", + "integrity": "sha512-McnNiV1l8RYeY8tBgEpuodCC1mLUdbSN+CYBL7kJsJNInOP8UjDDEwdk6Mw60vdLLrr5NHKZhMAOSrR2NZuQ+w==", + "dev": true, + "optional": true, + "dependencies": { + "safe-buffer": "^5.0.1" + }, + "engines": { + "node": "*" + } + }, + "node_modules/typed-rest-client": { + "version": "1.8.11", + "resolved": "https://registry.npmjs.org/typed-rest-client/-/typed-rest-client-1.8.11.tgz", + "integrity": "sha512-5UvfMpd1oelmUPRbbaVnq+rHP7ng2cE4qoQkQeAqxRL6PklkxsM0g32/HL0yfvruK6ojQ5x8EE+HF4YV6DtuCA==", + "dev": true, + "dependencies": { + "qs": "^6.9.1", + "tunnel": "0.0.6", + "underscore": "^1.12.1" + } + }, + "node_modules/uc.micro": { + "version": "1.0.6", + "resolved": "https://registry.npmjs.org/uc.micro/-/uc.micro-1.0.6.tgz", + "integrity": "sha512-8Y75pvTYkLJW2hWQHXxoqRgV7qb9B+9vFEtidML+7koHUFapnVJAZ6cKs+Qjz5Aw3aZWHMC6u0wJE3At+nSGwA==", + "dev": true + }, + "node_modules/underscore": { + "version": "1.13.7", + "resolved": "https://registry.npmjs.org/underscore/-/underscore-1.13.7.tgz", + "integrity": "sha512-GMXzWtsc57XAtguZgaQViUOzs0KTkk8ojr3/xAxXLITqf/3EMwxC0inyETfDFjH/Krbhuep0HNbbjI9i/q3F3g==", + "dev": true + }, + "node_modules/undici": { + "version": "7.13.0", + "resolved": "https://registry.npmjs.org/undici/-/undici-7.13.0.tgz", + "integrity": "sha512-l+zSMssRqrzDcb3fjMkjjLGmuiiK2pMIcV++mJaAc9vhjSGpvM7h43QgP+OAMb1GImHmbPyG2tBXeuyG5iY4gA==", + "dev": true, + "engines": { + "node": ">=20.18.1" + } + }, + "node_modules/url-join": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/url-join/-/url-join-4.0.1.tgz", + "integrity": "sha512-jk1+QP6ZJqyOiuEI9AEWQfju/nB2Pw466kbA0LEZljHwKeMgd9WrAEgEGxjPDD2+TNbbb37rTyhEfrCXfuKXnA==", + "dev": true + }, + "node_modules/util-deprecate": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz", + "integrity": "sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw==", + "dev": true, + "optional": true + }, + "node_modules/uuid": { + "version": "8.3.2", + "resolved": "https://registry.npmjs.org/uuid/-/uuid-8.3.2.tgz", + "integrity": "sha512-+NYs2QeMWy+GWFOEm9xnn6HCDp0l7QBD7ml8zLUmJ+93Q5NF0NocErnwkTkXVFNiX3/fpC6afS8Dhb/gz7R7eg==", + "dev": true, + "bin": { + "uuid": "dist/bin/uuid" + } + }, + "node_modules/whatwg-encoding": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/whatwg-encoding/-/whatwg-encoding-3.1.1.tgz", + "integrity": "sha512-6qN4hJdMwfYBtE3YBTTHhoeuUrDBPZmbQaxWAqSALV/MeEnR5z1xd8UKud2RAkFoPkmB+hli1TZSnyi84xz1vQ==", + "dev": true, + "dependencies": { + "iconv-lite": "0.6.3" + }, + "engines": { + "node": ">=18" + } + }, + "node_modules/whatwg-mimetype": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/whatwg-mimetype/-/whatwg-mimetype-4.0.0.tgz", + "integrity": "sha512-QaKxh0eNIi2mE9p2vEdzfagOKHCcj1pJ56EEHGQOVxp8r9/iszLUUV7v89x9O1p/T+NlTM5W7jW6+cz4Fq1YVg==", + "dev": true, + "engines": { + "node": ">=18" + } + }, + "node_modules/wrappy": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz", + "integrity": "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==", + "dev": true + }, + "node_modules/wsl-utils": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/wsl-utils/-/wsl-utils-0.1.0.tgz", + "integrity": "sha512-h3Fbisa2nKGPxCpm89Hk33lBLsnaGBvctQopaBSOW/uIs6FTe1ATyAnKFJrzVs9vpGdsTe73WF3V4lIsk4Gacw==", + "dev": true, + "dependencies": { + "is-wsl": "^3.1.0" + }, + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/xml2js": { + "version": "0.5.0", + "resolved": "https://registry.npmjs.org/xml2js/-/xml2js-0.5.0.tgz", + "integrity": "sha512-drPFnkQJik/O+uPKpqSgr22mpuFHqKdbS835iAQrUC73L2F5WkboIRd63ai/2Yg6I1jzifPFKH2NTK+cfglkIA==", + "dev": true, + "dependencies": { + "sax": ">=0.6.0", + "xmlbuilder": "~11.0.0" + }, + "engines": { + "node": ">=4.0.0" + } + }, + "node_modules/xmlbuilder": { + "version": "11.0.1", + "resolved": "https://registry.npmjs.org/xmlbuilder/-/xmlbuilder-11.0.1.tgz", + "integrity": "sha512-fDlsI/kFEx7gLvbecc0/ohLG50fugQp8ryHzMTuW9vSa1GJ0XYWKnhsUx7oie3G98+r56aTQIUB4kht42R3JvA==", + "dev": true, + "engines": { + "node": ">=4.0" + } + }, + "node_modules/yallist": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz", + "integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==", + "dev": true + }, + "node_modules/yauzl": { + "version": "2.10.0", + "resolved": "https://registry.npmjs.org/yauzl/-/yauzl-2.10.0.tgz", + "integrity": "sha512-p4a9I6X6nu6IhoGmBqAcbJy1mlC4j27vEPZX9F4L4/vZT3Lyq1VkFHw/V/PUcB9Buo+DG3iHkT0x3Qya58zc3g==", + "dev": true, + "dependencies": { + "buffer-crc32": "~0.2.3", + "fd-slicer": "~1.1.0" + } + }, + "node_modules/yazl": { + "version": "2.5.1", + "resolved": "https://registry.npmjs.org/yazl/-/yazl-2.5.1.tgz", + "integrity": "sha512-phENi2PLiHnHb6QBVot+dJnaAZ0xosj7p3fWl+znIjBDlnMI2PsZCJZ306BPTFOaHf5qdDEI8x5qFrSOBN5vrw==", + "dev": true, + "dependencies": { + "buffer-crc32": "~0.2.3" + } + } + } +} diff --git a/js/baba-yaga/dev/vscode/package.json b/js/baba-yaga/dev/vscode/package.json new file mode 100644 index 0000000..070207b --- /dev/null +++ b/js/baba-yaga/dev/vscode/package.json @@ -0,0 +1,174 @@ +{ + "name": "baba-yaga", + "displayName": "Baba Yaga", + "description": "Language support for Baba Yaga programming language", + "version": "1.1.1", + "publisher": "baba-yaga", + "engines": { + "vscode": "^1.74.0" + }, + "categories": [ + "Programming Languages", + "Snippets", + "Other" + ], + "keywords": [ + "baba-yaga", + "functional", + "programming", + "language" + ], + "activationEvents": [ + "onLanguage:baba-yaga", + "onLanguage:markdown" + ], + "main": "./extension.js", + "contributes": { + "languages": [ + { + "id": "baba-yaga", + "aliases": [ + "Baba Yaga", + "baba-yaga", + "baba" + ], + "extensions": [ + ".baba", + ".baba-yaga", + ".by" + ], + "configuration": "./language-configuration.json" + } + ], + "grammars": [ + { + "language": "baba-yaga", + "scopeName": "source.baba-yaga", + "path": "./syntaxes/baba-yaga.tmLanguage.json" + }, + { + "scopeName": "markdown.baba-yaga.codeblock", + "path": "./syntaxes/baba-yaga-markdown.tmLanguage.json", + "injectTo": [ + "text.html.markdown" + ], + "embeddedLanguages": { + "source.baba-yaga": "baba-yaga" + } + } + ], + "configuration": { + "title": "Baba Yaga", + "properties": { + "baba-yaga.enableTypeHints": { + "type": "boolean", + "default": true, + "description": "Show type hints and function signatures" + }, + "baba-yaga.enableFunctionReferences": { + "type": "boolean", + "default": true, + "description": "Enable function references and go-to-definition" + }, + "baba-yaga.enableAutoComplete": { + "type": "boolean", + "default": true, + "description": "Enable autocomplete for functions and variables" + }, + "baba-yaga.enableErrorChecking": { + "type": "boolean", + "default": false, + "description": "Enable real-time error checking (currently disabled to prevent false semicolon warnings)" + }, + "baba-yaga.enableMarkdownSupport": { + "type": "boolean", + "default": true, + "description": "Enable syntax highlighting for Baba Yaga code blocks in Markdown" + }, + "baba-yaga.typeHintMode": { + "type": "string", + "enum": [ + "none", + "inline", + "above" + ], + "default": "none", + "description": "Type hint display mode: 'none' (hover only), 'inline' (after expressions), 'above' (above expressions like Elm)" + } + } + }, + "commands": [ + { + "command": "baba-yaga.showTypeInfo", + "title": "Show Type Information", + "category": "Baba Yaga" + }, + { + "command": "baba-yaga.goToDefinition", + "title": "Go to Definition", + "category": "Baba Yaga" + }, + { + "command": "baba-yaga.findReferences", + "title": "Find References", + "category": "Baba Yaga" + }, + { + "command": "baba-yaga.showFunctionSignature", + "title": "Show Function Signature", + "category": "Baba Yaga" + }, + { + "command": "baba-yaga.autoFixSyntax", + "title": "Auto-Fix Syntax Issues", + "category": "Baba Yaga" + }, + { + "command": "baba-yaga.showSyntaxIssues", + "title": "Show Syntax Issues", + "category": "Baba Yaga" + } + ], + "keybindings": [ + { + "command": "baba-yaga.goToDefinition", + "key": "f12", + "when": "editorLangId == baba-yaga" + }, + { + "command": "baba-yaga.findReferences", + "key": "shift+f12", + "when": "editorLangId == baba-yaga" + }, + { + "command": "baba-yaga.showTypeInfo", + "key": "ctrl+shift+space", + "when": "editorLangId == baba-yaga" + }, + { + "command": "baba-yaga.autoFixSyntax", + "key": "ctrl+shift+f", + "when": "editorLangId == baba-yaga" + }, + { + "command": "baba-yaga.showSyntaxIssues", + "key": "ctrl+shift+i", + "when": "editorLangId == baba-yaga" + } + ], + "snippets": [ + { + "language": "baba-yaga", + "path": "./snippets/baba-yaga.json" + } + ] + }, + "scripts": { + "vscode:prepublish": "echo 'Extension ready for packaging'", + "package": "vsce package" + }, + "devDependencies": { + "@vscode/vsce": "^2.15.0" + }, + "license": "MIT" +} diff --git a/js/baba-yaga/dev/vscode/snippets/baba-yaga.json b/js/baba-yaga/dev/vscode/snippets/baba-yaga.json new file mode 100644 index 0000000..c791ede --- /dev/null +++ b/js/baba-yaga/dev/vscode/snippets/baba-yaga.json @@ -0,0 +1,133 @@ +{ + "Function Definition": { + "prefix": "func", + "body": [ + "${1:functionName} : ${2:parameters} -> ${3:body};" + ], + "description": "Define a function" + }, + "Typed Function": { + "prefix": "tfunc", + "body": [ + "${1:functionName} : (${2:param1}: ${3:Type1}, ${4:param2}: ${5:Type2}) -> ${6:ReturnType} -> ${7:body};" + ], + "description": "Define a typed function" + }, + "When Expression": { + "prefix": "when", + "body": [ + "when ${1:expression} is", + " ${2:pattern1} then ${3:result1}", + " ${4:pattern2} then ${5:result2}", + " _ then ${6:default};" + ], + "description": "Pattern matching with when expression" + }, + "Result Type": { + "prefix": "result", + "body": [ + "when ${1:expression} is", + " Ok ${2:value} then ${3:success}", + " Err ${4:error} then ${5:failure};" + ], + "description": "Handle Result type with pattern matching" + }, + "List": { + "prefix": "list", + "body": [ + "[${1:item1}, ${2:item2}, ${3:item3}]" + ], + "description": "Create a list" + }, + "Table": { + "prefix": "table", + "body": [ + "{${1:key1}: ${2:value1}, ${3:key2}: ${4:value2}}" + ], + "description": "Create a table" + }, + "Map": { + "prefix": "map", + "body": [ + "map (${1:x} -> ${2:expression}) ${3:list}" + ], + "description": "Apply function to list elements" + }, + "Filter": { + "prefix": "filter", + "body": [ + "filter (${1:x} -> ${2:predicate}) ${3:list}" + ], + "description": "Filter list by predicate" + }, + "Reduce": { + "prefix": "reduce", + "body": [ + "reduce (${1:acc} ${2:item} -> ${3:expression}) ${4:initial} ${5:list}" + ], + "description": "Fold list to single value" + }, + "IO Output": { + "prefix": "io.out", + "body": [ + "io.out ${1:value};" + ], + "description": "Print to console" + }, + "IO Input": { + "prefix": "io.in", + "body": [ + "io.in" + ], + "description": "Read from console" + }, + "String Function": { + "prefix": "str", + "body": [ + "str.${1:concat|split|join|length|substring|replace|trim|upper|lower} ${2:arguments}" + ], + "description": "String operation" + }, + "Math Function": { + "prefix": "math", + "body": [ + "math.${1:abs|sign|floor|ceil|round|trunc|min|max|clamp|pow|sqrt|exp|log|sin|cos|tan|asin|acos|atan|atan2|deg|rad|random|randomInt} ${2:arguments}" + ], + "description": "Math operation" + }, + "Type Declaration": { + "prefix": "type", + "body": [ + "${1:variableName} ${2:Type};" + ], + "description": "Declare a typed variable" + }, + "Variable Assignment": { + "prefix": "var", + "body": [ + "${1:variableName} : ${2:value};" + ], + "description": "Assign a value to a variable" + }, + "Comment": { + "prefix": "//", + "body": [ + "// ${1:comment}" + ], + "description": "Single line comment" + }, + "Arrow Function": { + "prefix": "arrow", + "body": [ + "${1:parameters} -> ${2:body}" + ], + "description": "Anonymous function" + }, + "Curried Function": { + "prefix": "curry", + "body": [ + "${1:param1} -> ${2:param2} -> ${3:body}" + ], + "description": "Curried function" + } +} diff --git a/js/baba-yaga/dev/vscode/syntaxes/baba-yaga-markdown.tmLanguage.json b/js/baba-yaga/dev/vscode/syntaxes/baba-yaga-markdown.tmLanguage.json new file mode 100644 index 0000000..2537b2c --- /dev/null +++ b/js/baba-yaga/dev/vscode/syntaxes/baba-yaga-markdown.tmLanguage.json @@ -0,0 +1,34 @@ +{ + "scopeName": "markdown.baba-yaga.codeblock", + "patterns": [ + { + "begin": "(^|\\G)(\\s*)(```)(baba|baba-yaga)(?:\\s*$|\\s+([^\\r\\n]*)$)", + "beginCaptures": { + "3": { + "name": "punctuation.definition.markdown" + }, + "4": { + "name": "fenced_code.block.language" + }, + "5": { + "name": "fenced_code.block.language.attributes" + } + }, + "end": "(^|\\G)(\\s*)(```)", + "endCaptures": { + "3": { + "name": "punctuation.definition.markdown" + } + }, + "name": "markup.fenced_code.block.markdown", + "contentName": "source.baba-yaga", + "patterns": [ + { + "include": "source.baba-yaga" + } + ] + } + ] +} + + diff --git a/js/baba-yaga/dev/vscode/syntaxes/baba-yaga.tmLanguage.json b/js/baba-yaga/dev/vscode/syntaxes/baba-yaga.tmLanguage.json new file mode 100644 index 0000000..9ecb3b0 --- /dev/null +++ b/js/baba-yaga/dev/vscode/syntaxes/baba-yaga.tmLanguage.json @@ -0,0 +1,252 @@ +{ + "name": "Baba Yaga", + "scopeName": "source.baba-yaga", + "fileTypes": ["baba"], + "patterns": [ + { + "include": "#comments" + }, + { + "include": "#strings" + }, + { + "include": "#numbers" + }, + { + "include": "#function-types" + }, + { + "include": "#with-blocks" + }, + { + "include": "#keywords" + }, + { + "include": "#operators" + }, + { + "include": "#types" + }, + { + "include": "#functions" + }, + { + "include": "#identifiers" + } + ], + "repository": { + "comments": { + "patterns": [ + { + "name": "comment.line.double-slash.baba-yaga", + "match": "//.*$" + } + ] + }, + "strings": { + "patterns": [ + { + "name": "string.quoted.double.baba-yaga", + "begin": "\"", + "end": "\"", + "patterns": [ + { + "name": "constant.character.escape.baba-yaga", + "match": "\\\\." + } + ] + } + ] + }, + "numbers": { + "patterns": [ + { + "name": "constant.numeric.integer.baba-yaga", + "match": "\\b\\d+\\b" + }, + { + "name": "constant.numeric.float.baba-yaga", + "match": "\\b\\d+\\.\\d+\\b" + } + ] + }, + "keywords": { + "patterns": [ + { + "name": "keyword.control.baba-yaga", + "match": "\\b(when|then|is|Ok|Err|true|false|PI|INFINITY|and|or|xor)\\b" + } + ] + }, + "with-blocks": { + "patterns": [ + { + "name": "keyword.control.with.baba-yaga", + "match": "\\bwith\\b" + }, + { + "name": "keyword.control.with-rec.baba-yaga", + "match": "\\bwith\\s+rec\\b" + }, + { + "name": "meta.with-block.baba-yaga", + "begin": "with\\s*\\(\\s*(?:rec\\s*)?", + "end": "\\)\\s*->", + "beginCaptures": { + "0": { "name": "keyword.control.with.baba-yaga" } + }, + "endCaptures": { + "0": { "name": "keyword.operator.arrow.baba-yaga" } + }, + "patterns": [ + { + "include": "#comments" + }, + { + "include": "#with-block-entries" + }, + { + "include": "#types" + }, + { + "include": "#operators" + }, + { + "include": "#identifiers" + } + ] + } + ] + }, + "with-block-entries": { + "patterns": [ + { + "name": "meta.with-block-entry.baba-yaga", + "begin": "([a-zA-Z_][a-zA-Z0-9_]*)\\s*:", + "end": ";", + "beginCaptures": { + "1": { "name": "variable.other.with-local.baba-yaga" } + }, + "endCaptures": { + "0": { "name": "punctuation.terminator.semicolon.baba-yaga" } + }, + "patterns": [ + { + "include": "#comments" + }, + { + "include": "#when-expressions" + }, + { + "include": "#types" + }, + { + "include": "#operators" + }, + { + "include": "#identifiers" + } + ] + } + ] + }, + "when-expressions": { + "patterns": [ + { + "name": "meta.when-expression.baba-yaga", + "begin": "when\\s+", + "end": ";", + "beginCaptures": { + "0": { "name": "keyword.control.when.baba-yaga" } + }, + "endCaptures": { + "0": { "name": "punctuation.terminator.semicolon.baba-yaga" } + }, + "patterns": [ + { + "include": "#comments" + }, + { + "include": "#types" + }, + { + "include": "#operators" + }, + { + "include": "#identifiers" + } + ] + } + ] + }, + "operators": { + "patterns": [ + { + "name": "keyword.operator.arrow.baba-yaga", + "match": "->" + }, + { + "name": "keyword.operator.baba-yaga", + "match": "(\\+|-|\\*|/|%|=|!=|>|<|>=|<=|\\.\\.|:)" + } + ] + }, + "function-types": { + "patterns": [ + { + "name": "meta.function-type.baba-yaga", + "begin": "\\(", + "end": "\\)", + "beginCaptures": { + "0": { "name": "punctuation.definition.type.begin.baba-yaga" } + }, + "endCaptures": { + "0": { "name": "punctuation.definition.type.end.baba-yaga" } + }, + "patterns": [ + { + "include": "#types" + }, + { + "include": "#operators" + }, + { + "include": "#function-types" + } + ] + } + ] + }, + "types": { + "patterns": [ + { + "name": "storage.type.baba-yaga", + "match": "\\b(Bool|Int|Float|String|List|Table|Result|Number)\\b" + } + ] + }, + "functions": { + "patterns": [ + { + "name": "entity.name.function.declaration.baba-yaga", + "match": "\\b([a-zA-Z_][a-zA-Z0-9_]*)\\s*:", + "captures": { + "1": { "name": "entity.name.function.baba-yaga" } + } + }, + { + "name": "support.function.builtin.baba-yaga", + "match": "\\b(io\\.(out|in)|map|filter|reduce|append|set|merge|shape|str\\.(concat|split|join|length|substring|replace|trim|upper|lower)|math\\.(abs|sign|floor|ceil|round|trunc|min|max|clamp|pow|sqrt|exp|log|sin|cos|tan|asin|acos|atan|atan2|deg|rad|random|randomInt))\\b" + } + ] + }, + "identifiers": { + "patterns": [ + { + "name": "variable.other.baba-yaga", + "match": "\\b[a-zA-Z_][a-zA-Z0-9_]*\\b" + } + ] + } + } +} diff --git a/js/baba-yaga/dev/vscode/test-linting.baba b/js/baba-yaga/dev/vscode/test-linting.baba new file mode 100644 index 0000000..e7ac2dc --- /dev/null +++ b/js/baba-yaga/dev/vscode/test-linting.baba @@ -0,0 +1,35 @@ +// Test file to verify no false linting errors +// This should not show any semicolon warnings + +// Arrow function definitions (no semicolons needed) +add : x y -> x + y; +multiply : x y -> x * y; + +// Pattern matching (no semicolons in cases) +matchValue : value -> + when value is + 42 then "The Answer" + "hello" then "Greeting" + _ then "Unknown"; + +// Table pattern matching +matchTable : table -> + when table is + { name: "Alice" age: 30 } then "Exact Table Match" + { name: "Bob" age: _ } then "Table with Wildcard Value Match" + _ then "No Table Match"; + +// List operations +numbers : [1, 2, 3, 4, 5]; +doubled : map(x -> x * 2, numbers); +filtered : filter(x -> x > 2, numbers); + +// Function calls and expressions +result : add(5, multiply(3, 4)); +greeting : str.concat("Hello", " World"); + +// No semicolon needed after these expressions +if result > 20 then + "Large result" +else + "Small result" diff --git a/js/baba-yaga/dev/vscode/test-markdown.md b/js/baba-yaga/dev/vscode/test-markdown.md new file mode 100644 index 0000000..e387cb5 --- /dev/null +++ b/js/baba-yaga/dev/vscode/test-markdown.md @@ -0,0 +1,38 @@ +# Baba Yaga Code Examples + +Here's some regular text. + +```baba +// This is a comment - should not have type hints +add : Int -> Int -> Int; +add(x, y) : x + y; + +// Another comment +result : add(5, 3); // Should show type hint here +name : "World"; +greeting : str.concat("Hello, ", name); // Should show type hint + +result_check : when result is + 8 then "correct" + _ then "wrong"; + +// Math example +value : math.sqrt(16); +``` + +More regular markdown text. + +```javascript +// This is JavaScript, not Baba Yaga +function test() { + return 42; +} +``` + +Another Baba Yaga block: + +```baba-yaga +// Alternative syntax +list : [1, 2, 3]; +doubled : map(x -> x * 2, list); +``` diff --git a/js/baba-yaga/dev/vscode/type-modes-test.baba b/js/baba-yaga/dev/vscode/type-modes-test.baba new file mode 100644 index 0000000..93b8963 --- /dev/null +++ b/js/baba-yaga/dev/vscode/type-modes-test.baba @@ -0,0 +1,44 @@ +// Baba Yaga Type Hints Test File +// Test all three type hint modes: none, inline, above + +// Function definitions +add : Int -> Int -> Int; +add(x, y) : x + y; + +multiply : Int -> Int -> Int; +multiply(x, y) : x * y; + +// Basic expressions - should show type hints +result : add(5, 3); +product : multiply(4, 6); + +// String operations - should show type hints +name : "World"; +greeting : str.concat("Hello, ", name); +length : str.length(greeting); + +// Math operations - should show type hints +value : math.sqrt(16); +rounded : math.round(3.14159); + +// List operations - should show type hints +numbers : [1, 2, 3, 4, 5]; +doubled : map(x -> x * 2, numbers); +evens : filter(x -> x % 2 = 0, doubled); + +// Pattern matching - should show type hints +check_result : when result is + 8 then Ok("correct") + _ then Err("wrong"); + +// Result handling - should show type hints +success : Ok("success"); +failure : Err("failure"); + +// Comments should NOT show type hints +// This is a comment with add(1, 2) and str.concat("test", "test") +// No type hints should appear here + +// IO operations - should show type hints +io.out("Testing type hints"); +user_input : io.in(); |