@enjoys/context-engine 1.1.0 → 1.1.1

package/data/completion/swift.json

@@ -0,0 +1,1742 @@
+{
+  "language": "swift",
+  "completions": [
+    {
+      "label": "func",
+      "kind": 17,
+      "detail": "Function declaration keyword",
+      "documentation": {"value": "```swift\nfunc name(param: Type) -> ReturnType {\n    // body\n}\n```\nDeclares a function."},
+      "insertText": "func ${1:name}(${2:params}) -> ${3:Void} {\n\t$0\n}",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_func"
+    },
+    {
+      "label": "let",
+      "kind": 17,
+      "detail": "Immutable variable declaration",
+      "documentation": {"value": "```swift\nlet name: Type = value\n```\nDeclares an immutable constant."},
+      "insertText": "let ${1:name}: ${2:Type} = ${3:value}",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_let"
+    },
+    {
+      "label": "var",
+      "kind": 17,
+      "detail": "Mutable variable declaration",
+      "documentation": {"value": "```swift\nvar name: Type = value\n```\nDeclares a mutable variable."},
+      "insertText": "var ${1:name}: ${2:Type} = ${3:value}",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_var"
+    },
+    {
+      "label": "class",
+      "kind": 17,
+      "detail": "Class declaration keyword",
+      "documentation": {"value": "```swift\nclass Name: SuperClass {\n    // body\n}\n```\nDeclares a reference-type class."},
+      "insertText": "class ${1:Name} {\n\t$0\n}",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_class"
+    },
+    {
+      "label": "struct",
+      "kind": 17,
+      "detail": "Struct declaration keyword",
+      "documentation": {"value": "```swift\nstruct Name {\n    // body\n}\n```\nDeclares a value-type struct."},
+      "insertText": "struct ${1:Name} {\n\t$0\n}",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_struct"
+    },
+    {
+      "label": "enum",
+      "kind": 17,
+      "detail": "Enum declaration keyword",
+      "documentation": {"value": "```swift\nenum Name {\n    case value1\n    case value2\n}\n```\nDeclares an enumeration type."},
+      "insertText": "enum ${1:Name} {\n\tcase ${2:value}\n\t$0\n}",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_enum"
+    },
+    {
+      "label": "protocol",
+      "kind": 17,
+      "detail": "Protocol declaration keyword",
+      "documentation": {"value": "```swift\nprotocol Name {\n    func method()\n}\n```\nDeclares a protocol (interface)."},
+      "insertText": "protocol ${1:Name} {\n\t$0\n}",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_protocol"
+    },
+    {
+      "label": "extension",
+      "kind": 17,
+      "detail": "Extension declaration keyword",
+      "documentation": {"value": "```swift\nextension Type {\n    // added functionality\n}\n```\nExtends an existing type with new functionality."},
+      "insertText": "extension ${1:Type} {\n\t$0\n}",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_extension"
+    },
+    {
+      "label": "import",
+      "kind": 17,
+      "detail": "Import declaration keyword",
+      "documentation": {"value": "```swift\nimport Foundation\n```\nImports a module."},
+      "insertText": "import ${1:Foundation}",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_import"
+    },
+    {
+      "label": "return",
+      "kind": 17,
+      "detail": "Return keyword",
+      "documentation": {"value": "```swift\nreturn value\n```\nReturns a value from a function."},
+      "insertText": "return ${1:value}",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_return"
+    },
+    {
+      "label": "if",
+      "kind": 17,
+      "detail": "Conditional keyword",
+      "documentation": {"value": "```swift\nif condition {\n    // body\n}\n```\nConditional statement."},
+      "insertText": "if ${1:condition} {\n\t$0\n}",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_if"
+    },
+    {
+      "label": "else",
+      "kind": 17,
+      "detail": "Else branch keyword",
+      "documentation": {"value": "```swift\nif condition {\n    // if body\n} else {\n    // else body\n}\n```\nElse branch of conditional."},
+      "insertText": "else {\n\t$0\n}",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_else"
+    },
+    {
+      "label": "guard",
+      "kind": 17,
+      "detail": "Guard statement keyword",
+      "documentation": {"value": "```swift\nguard condition else {\n    return\n}\n```\nEarly exit guard statement."},
+      "insertText": "guard ${1:condition} else {\n\t${2:return}\n}",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_guard"
+    },
+    {
+      "label": "switch",
+      "kind": 17,
+      "detail": "Switch statement keyword",
+      "documentation": {"value": "```swift\nswitch value {\ncase .option1:\n    // ...\ndefault:\n    break\n}\n```\nPattern matching switch statement."},
+      "insertText": "switch ${1:value} {\ncase ${2:.option}:\n\t${3:break}\ndefault:\n\t${4:break}\n}",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_switch"
+    },
+    {
+      "label": "case",
+      "kind": 17,
+      "detail": "Case keyword",
+      "documentation": {"value": "```swift\ncase .value:\n    // handler\n```\nSwitch case or enum case."},
+      "insertText": "case ${1:.value}:\n\t$0",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_case"
+    },
+    {
+      "label": "default",
+      "kind": 17,
+      "detail": "Default case keyword",
+      "documentation": {"value": "```swift\ndefault:\n    break\n```\nDefault case in switch statement."},
+      "insertText": "default:\n\t$0",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_default"
+    },
+    {
+      "label": "for",
+      "kind": 17,
+      "detail": "For-in loop keyword",
+      "documentation": {"value": "```swift\nfor item in collection {\n    // body\n}\n```\nIterates over a sequence."},
+      "insertText": "for ${1:item} in ${2:collection} {\n\t$0\n}",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_for"
+    },
+    {
+      "label": "while",
+      "kind": 17,
+      "detail": "While loop keyword",
+      "documentation": {"value": "```swift\nwhile condition {\n    // body\n}\n```\nRepeats while condition is true."},
+      "insertText": "while ${1:condition} {\n\t$0\n}",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_while"
+    },
+    {
+      "label": "repeat",
+      "kind": 17,
+      "detail": "Repeat-while loop keyword",
+      "documentation": {"value": "```swift\nrepeat {\n    // body\n} while condition\n```\nExecutes body at least once."},
+      "insertText": "repeat {\n\t$0\n} while ${1:condition}",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_repeat"
+    },
+    {
+      "label": "break",
+      "kind": 17,
+      "detail": "Break statement keyword",
+      "documentation": {"value": "Exits the current loop or switch case."},
+      "insertText": "break",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_break"
+    },
+    {
+      "label": "continue",
+      "kind": 17,
+      "detail": "Continue statement keyword",
+      "documentation": {"value": "Skips the current iteration and continues with the next."},
+      "insertText": "continue",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_continue"
+    },
+    {
+      "label": "fallthrough",
+      "kind": 17,
+      "detail": "Fallthrough keyword",
+      "documentation": {"value": "Causes execution to fall through to the next case in a switch statement."},
+      "insertText": "fallthrough",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_fallthrough"
+    },
+    {
+      "label": "throw",
+      "kind": 17,
+      "detail": "Throw keyword",
+      "documentation": {"value": "```swift\nthrow MyError.someError\n```\nThrows an error."},
+      "insertText": "throw ${1:error}",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_throw"
+    },
+    {
+      "label": "throws",
+      "kind": 17,
+      "detail": "Throws keyword",
+      "documentation": {"value": "Marks a function that can throw errors."},
+      "insertText": "throws",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_throws"
+    },
+    {
+      "label": "rethrows",
+      "kind": 17,
+      "detail": "Rethrows keyword",
+      "documentation": {"value": "Marks a function that throws only if its closure argument throws."},
+      "insertText": "rethrows",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_rethrows"
+    },
+    {
+      "label": "try",
+      "kind": 17,
+      "detail": "Try keyword",
+      "documentation": {"value": "```swift\ntry expression\ntry? expression\ntry! expression\n```\nAttempts a throwing expression."},
+      "insertText": "try ${1:expression}",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_try"
+    },
+    {
+      "label": "catch",
+      "kind": 17,
+      "detail": "Catch keyword",
+      "documentation": {"value": "```swift\ncatch let error {\n    // handle error\n}\n```\nCatches an error from a do block."},
+      "insertText": "catch ${1:let error} {\n\t$0\n}",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_catch"
+    },
+    {
+      "label": "do",
+      "kind": 17,
+      "detail": "Do block keyword",
+      "documentation": {"value": "```swift\ndo {\n    try expression\n} catch {\n    // handle\n}\n```\nIntroduces a do-catch error handling block."},
+      "insertText": "do {\n\t${1:try expression}\n} catch {\n\t$0\n}",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_do"
+    },
+    {
+      "label": "defer",
+      "kind": 17,
+      "detail": "Defer keyword",
+      "documentation": {"value": "```swift\ndefer {\n    // cleanup code\n}\n```\nExecutes code when leaving the current scope."},
+      "insertText": "defer {\n\t$0\n}",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_defer"
+    },
+    {
+      "label": "as",
+      "kind": 17,
+      "detail": "Type casting keyword",
+      "documentation": {"value": "Type cast operator. Use `as`, `as?`, or `as!`."},
+      "insertText": "as ${1:Type}",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_as"
+    },
+    {
+      "label": "is",
+      "kind": 17,
+      "detail": "Type check keyword",
+      "documentation": {"value": "Checks if a value is of a certain type."},
+      "insertText": "is ${1:Type}",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_is"
+    },
+    {
+      "label": "in",
+      "kind": 17,
+      "detail": "In keyword",
+      "documentation": {"value": "Used in for-in loops and closure parameters."},
+      "insertText": "in",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_in"
+    },
+    {
+      "label": "where",
+      "kind": 17,
+      "detail": "Where clause keyword",
+      "documentation": {"value": "Adds constraints to generic types or pattern matching."},
+      "insertText": "where ${1:T}: ${2:Protocol}",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_where"
+    },
+    {
+      "label": "self",
+      "kind": 17,
+      "detail": "Self reference keyword",
+      "documentation": {"value": "Refers to the current instance."},
+      "insertText": "self",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_self"
+    },
+    {
+      "label": "Self",
+      "kind": 17,
+      "detail": "Self type keyword",
+      "documentation": {"value": "Refers to the current type in protocol or class context."},
+      "insertText": "Self",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_Self"
+    },
+    {
+      "label": "super",
+      "kind": 17,
+      "detail": "Super reference keyword",
+      "documentation": {"value": "Refers to the superclass."},
+      "insertText": "super",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_super"
+    },
+    {
+      "label": "init",
+      "kind": 17,
+      "detail": "Initializer keyword",
+      "documentation": {"value": "```swift\ninit(param: Type) {\n    self.param = param\n}\n```\nDeclares an initializer."},
+      "insertText": "init(${1:params}) {\n\t$0\n}",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_init"
+    },
+    {
+      "label": "deinit",
+      "kind": 17,
+      "detail": "Deinitializer keyword",
+      "documentation": {"value": "```swift\ndeinit {\n    // cleanup\n}\n```\nCalled when an instance is deallocated."},
+      "insertText": "deinit {\n\t$0\n}",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_deinit"
+    },
+    {
+      "label": "subscript",
+      "kind": 17,
+      "detail": "Subscript keyword",
+      "documentation": {"value": "```swift\nsubscript(index: Int) -> Element {\n    get { ... }\n    set { ... }\n}\n```\nEnables subscript access."},
+      "insertText": "subscript(${1:index}: ${2:Int}) -> ${3:Element} {\n\t$0\n}",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_subscript"
+    },
+    {
+      "label": "typealias",
+      "kind": 17,
+      "detail": "Type alias keyword",
+      "documentation": {"value": "```swift\ntypealias Name = ExistingType\n```\nCreates a named alias for an existing type."},
+      "insertText": "typealias ${1:Name} = ${2:Type}",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_typealias"
+    },
+    {
+      "label": "associatedtype",
+      "kind": 17,
+      "detail": "Associated type keyword",
+      "documentation": {"value": "```swift\nassociatedtype Element\n```\nDeclares an associated type in a protocol."},
+      "insertText": "associatedtype ${1:Element}",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_associatedtype"
+    },
+    {
+      "label": "static",
+      "kind": 17,
+      "detail": "Static keyword",
+      "documentation": {"value": "Declares a type-level (static) member."},
+      "insertText": "static ",
+      "insertTextRules": 4,
+      "sortText": "02_modifier_static"
+    },
+    {
+      "label": "final",
+      "kind": 17,
+      "detail": "Final keyword",
+      "documentation": {"value": "Prevents a class, method, or property from being overridden."},
+      "insertText": "final ",
+      "insertTextRules": 4,
+      "sortText": "02_modifier_final"
+    },
+    {
+      "label": "lazy",
+      "kind": 17,
+      "detail": "Lazy keyword",
+      "documentation": {"value": "```swift\nlazy var name: Type = expression\n```\nDelays initialization until first access."},
+      "insertText": "lazy var ${1:name}: ${2:Type} = ${3:value}",
+      "insertTextRules": 4,
+      "sortText": "02_modifier_lazy"
+    },
+    {
+      "label": "weak",
+      "kind": 17,
+      "detail": "Weak reference keyword",
+      "documentation": {"value": "```swift\nweak var delegate: Protocol?\n```\nCreates a weak reference to avoid retain cycles."},
+      "insertText": "weak var ${1:name}: ${2:Type}?",
+      "insertTextRules": 4,
+      "sortText": "02_modifier_weak"
+    },
+    {
+      "label": "unowned",
+      "kind": 17,
+      "detail": "Unowned reference keyword",
+      "documentation": {"value": "Creates an unowned reference that is not optional."},
+      "insertText": "unowned ",
+      "insertTextRules": 4,
+      "sortText": "02_modifier_unowned"
+    },
+    {
+      "label": "optional",
+      "kind": 17,
+      "detail": "Optional requirement keyword",
+      "documentation": {"value": "Marks a protocol requirement as optional (requires @objc)."},
+      "insertText": "optional ",
+      "insertTextRules": 4,
+      "sortText": "02_modifier_optional"
+    },
+    {
+      "label": "required",
+      "kind": 17,
+      "detail": "Required initializer keyword",
+      "documentation": {"value": "Requires all subclasses to implement this initializer."},
+      "insertText": "required ",
+      "insertTextRules": 4,
+      "sortText": "02_modifier_required"
+    },
+    {
+      "label": "convenience",
+      "kind": 17,
+      "detail": "Convenience initializer keyword",
+      "documentation": {"value": "```swift\nconvenience init() {\n    self.init(param: default)\n}\n```\nDeclares a convenience initializer."},
+      "insertText": "convenience init(${1:params}) {\n\tself.init(${2:args})\n}",
+      "insertTextRules": 4,
+      "sortText": "02_modifier_convenience"
+    },
+    {
+      "label": "mutating",
+      "kind": 17,
+      "detail": "Mutating keyword",
+      "documentation": {"value": "Allows a method to modify value type properties."},
+      "insertText": "mutating func ${1:name}(${2:params}) {\n\t$0\n}",
+      "insertTextRules": 4,
+      "sortText": "02_modifier_mutating"
+    },
+    {
+      "label": "nonmutating",
+      "kind": 17,
+      "detail": "Nonmutating keyword",
+      "documentation": {"value": "Indicates a setter that does not modify the instance."},
+      "insertText": "nonmutating ",
+      "insertTextRules": 4,
+      "sortText": "02_modifier_nonmutating"
+    },
+    {
+      "label": "override",
+      "kind": 17,
+      "detail": "Override keyword",
+      "documentation": {"value": "Overrides a superclass method or property."},
+      "insertText": "override ",
+      "insertTextRules": 4,
+      "sortText": "02_modifier_override"
+    },
+    {
+      "label": "open",
+      "kind": 17,
+      "detail": "Open access modifier",
+      "documentation": {"value": "Allows access and overriding outside the module."},
+      "insertText": "open ",
+      "insertTextRules": 4,
+      "sortText": "02_modifier_open"
+    },
+    {
+      "label": "public",
+      "kind": 17,
+      "detail": "Public access modifier",
+      "documentation": {"value": "Allows access outside the module but not overriding."},
+      "insertText": "public ",
+      "insertTextRules": 4,
+      "sortText": "02_modifier_public"
+    },
+    {
+      "label": "internal",
+      "kind": 17,
+      "detail": "Internal access modifier",
+      "documentation": {"value": "Default access level; accessible within the module."},
+      "insertText": "internal ",
+      "insertTextRules": 4,
+      "sortText": "02_modifier_internal"
+    },
+    {
+      "label": "fileprivate",
+      "kind": 17,
+      "detail": "Fileprivate access modifier",
+      "documentation": {"value": "Restricts access to the enclosing file."},
+      "insertText": "fileprivate ",
+      "insertTextRules": 4,
+      "sortText": "02_modifier_fileprivate"
+    },
+    {
+      "label": "private",
+      "kind": 17,
+      "detail": "Private access modifier",
+      "documentation": {"value": "Restricts access to the enclosing declaration."},
+      "insertText": "private ",
+      "insertTextRules": 4,
+      "sortText": "02_modifier_private"
+    },
+    {
+      "label": "inout",
+      "kind": 17,
+      "detail": "In-out parameter keyword",
+      "documentation": {"value": "Passes a parameter by reference so it can be modified."},
+      "insertText": "inout ",
+      "insertTextRules": 4,
+      "sortText": "02_modifier_inout"
+    },
+    {
+      "label": "some",
+      "kind": 17,
+      "detail": "Opaque type keyword",
+      "documentation": {"value": "```swift\nfunc make() -> some View { ... }\n```\nDeclares an opaque return type."},
+      "insertText": "some ${1:Protocol}",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_some"
+    },
+    {
+      "label": "any",
+      "kind": 17,
+      "detail": "Existential type keyword",
+      "documentation": {"value": "```swift\nvar value: any Protocol\n```\nDeclares an existential type."},
+      "insertText": "any ${1:Protocol}",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_any"
+    },
+    {
+      "label": "async",
+      "kind": 17,
+      "detail": "Async keyword",
+      "documentation": {"value": "```swift\nfunc fetchData() async -> Data { ... }\n```\nMarks a function as asynchronous."},
+      "insertText": "async ",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_async"
+    },
+    {
+      "label": "await",
+      "kind": 17,
+      "detail": "Await keyword",
+      "documentation": {"value": "```swift\nlet result = await fetchData()\n```\nSuspends execution until async call completes."},
+      "insertText": "await ${1:expression}",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_await"
+    },
+    {
+      "label": "actor",
+      "kind": 17,
+      "detail": "Actor declaration keyword",
+      "documentation": {"value": "```swift\nactor MyActor {\n    var state: Int = 0\n}\n```\nDeclares a reference type that protects its state from data races."},
+      "insertText": "actor ${1:Name} {\n\t$0\n}",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_actor"
+    },
+    {
+      "label": "nonisolated",
+      "kind": 17,
+      "detail": "Nonisolated keyword",
+      "documentation": {"value": "Opts a member out of actor isolation."},
+      "insertText": "nonisolated ",
+      "insertTextRules": 4,
+      "sortText": "02_modifier_nonisolated"
+    },
+    {
+      "label": "isolated",
+      "kind": 17,
+      "detail": "Isolated keyword",
+      "documentation": {"value": "Specifies the actor isolation for a parameter."},
+      "insertText": "isolated ",
+      "insertTextRules": 4,
+      "sortText": "02_modifier_isolated"
+    },
+    {
+      "label": "consuming",
+      "kind": 17,
+      "detail": "Consuming ownership keyword",
+      "documentation": {"value": "Transfers ownership of the parameter to the function."},
+      "insertText": "consuming ",
+      "insertTextRules": 4,
+      "sortText": "02_modifier_consuming"
+    },
+    {
+      "label": "borrowing",
+      "kind": 17,
+      "detail": "Borrowing ownership keyword",
+      "documentation": {"value": "Borrows the parameter without taking ownership."},
+      "insertText": "borrowing ",
+      "insertTextRules": 4,
+      "sortText": "02_modifier_borrowing"
+    },
+    {
+      "label": "@MainActor",
+      "kind": 17,
+      "detail": "Main actor attribute",
+      "documentation": {"value": "```swift\n@MainActor\nclass ViewModel { ... }\n```\nEnsures the declaration runs on the main actor."},
+      "insertText": "@MainActor\n",
+      "insertTextRules": 4,
+      "sortText": "03_attribute_MainActor"
+    },
+    {
+      "label": "@Published",
+      "kind": 17,
+      "detail": "Published property wrapper",
+      "documentation": {"value": "```swift\n@Published var value: Type\n```\nPublishes changes for Combine subscribers."},
+      "insertText": "@Published var ${1:name}: ${2:Type}",
+      "insertTextRules": 4,
+      "sortText": "03_attribute_Published"
+    },
+    {
+      "label": "@State",
+      "kind": 17,
+      "detail": "State property wrapper",
+      "documentation": {"value": "```swift\n@State private var value: Type\n```\nManages local state in SwiftUI views."},
+      "insertText": "@State private var ${1:name}: ${2:Type} = ${3:value}",
+      "insertTextRules": 4,
+      "sortText": "03_attribute_State"
+    },
+    {
+      "label": "@Binding",
+      "kind": 17,
+      "detail": "Binding property wrapper",
+      "documentation": {"value": "```swift\n@Binding var value: Type\n```\nCreates a two-way connection to a state value."},
+      "insertText": "@Binding var ${1:name}: ${2:Type}",
+      "insertTextRules": 4,
+      "sortText": "03_attribute_Binding"
+    },
+    {
+      "label": "@Observable",
+      "kind": 17,
+      "detail": "Observable macro",
+      "documentation": {"value": "```swift\n@Observable\nclass Model { ... }\n```\nMakes a class automatically observable (Swift 5.9+)."},
+      "insertText": "@Observable\nclass ${1:Name} {\n\t$0\n}",
+      "insertTextRules": 4,
+      "sortText": "03_attribute_Observable"
+    },
+    {
+      "label": "print",
+      "kind": 1,
+      "detail": "Print to standard output",
+      "documentation": {"value": "```swift\nfunc print(_ items: Any..., separator: String = \" \", terminator: String = \"\\n\")\n```\nWrites textual representations to standard output."},
+      "insertText": "print(${1:items})",
+      "insertTextRules": 4,
+      "sortText": "04_function_print"
+    },
+    {
+      "label": "debugPrint",
+      "kind": 1,
+      "detail": "Debug print to standard output",
+      "documentation": {"value": "```swift\nfunc debugPrint(_ items: Any..., separator: String = \" \", terminator: String = \"\\n\")\n```\nWrites debug textual representations to standard output."},
+      "insertText": "debugPrint(${1:items})",
+      "insertTextRules": 4,
+      "sortText": "04_function_debugPrint"
+    },
+    {
+      "label": "dump",
+      "kind": 1,
+      "detail": "Dump object to output",
+      "documentation": {"value": "```swift\nfunc dump<T>(_ value: T, name: String? = nil, indent: Int = 0, maxDepth: Int = .max, maxItems: Int = .max) -> T\n```\nDumps an object's contents using its mirror."},
+      "insertText": "dump(${1:value})",
+      "insertTextRules": 4,
+      "sortText": "04_function_dump"
+    },
+    {
+      "label": "min",
+      "kind": 1,
+      "detail": "Return minimum value",
+      "documentation": {"value": "```swift\nfunc min<T: Comparable>(_ x: T, _ y: T) -> T\n```\nReturns the lesser of two comparable values."},
+      "insertText": "min(${1:x}, ${2:y})",
+      "insertTextRules": 4,
+      "sortText": "04_function_min"
+    },
+    {
+      "label": "max",
+      "kind": 1,
+      "detail": "Return maximum value",
+      "documentation": {"value": "```swift\nfunc max<T: Comparable>(_ x: T, _ y: T) -> T\n```\nReturns the greater of two comparable values."},
+      "insertText": "max(${1:x}, ${2:y})",
+      "insertTextRules": 4,
+      "sortText": "04_function_max"
+    },
+    {
+      "label": "abs",
+      "kind": 1,
+      "detail": "Absolute value",
+      "documentation": {"value": "```swift\nfunc abs<T: Comparable & SignedNumeric>(_ x: T) -> T\n```\nReturns the absolute value of the given number."},
+      "insertText": "abs(${1:x})",
+      "insertTextRules": 4,
+      "sortText": "04_function_abs"
+    },
+    {
+      "label": "stride",
+      "kind": 1,
+      "detail": "Create stride sequence",
+      "documentation": {"value": "```swift\nfunc stride<T>(from: T, to: T, by: T.Stride) -> StrideTo<T>\n```\nReturns a sequence from start to (but not including) end."},
+      "insertText": "stride(from: ${1:start}, to: ${2:end}, by: ${3:step})",
+      "insertTextRules": 4,
+      "sortText": "04_function_stride"
+    },
+    {
+      "label": "zip",
+      "kind": 1,
+      "detail": "Zip two sequences",
+      "documentation": {"value": "```swift\nfunc zip<Sequence1, Sequence2>(_ sequence1: Sequence1, _ sequence2: Sequence2) -> Zip2Sequence<Sequence1, Sequence2>\n```\nCreates a sequence of pairs from two sequences."},
+      "insertText": "zip(${1:sequence1}, ${2:sequence2})",
+      "insertTextRules": 4,
+      "sortText": "04_function_zip"
+    },
+    {
+      "label": "map",
+      "kind": 1,
+      "detail": "Transform elements",
+      "documentation": {"value": "```swift\nfunc map<T>(_ transform: (Element) throws -> T) rethrows -> [T]\n```\nReturns an array containing results of mapping the given closure."},
+      "insertText": "map { ${1:element} in\n\t$0\n}",
+      "insertTextRules": 4,
+      "sortText": "04_function_map"
+    },
+    {
+      "label": "filter",
+      "kind": 1,
+      "detail": "Filter elements",
+      "documentation": {"value": "```swift\nfunc filter(_ isIncluded: (Element) throws -> Bool) rethrows -> [Element]\n```\nReturns elements satisfying the given predicate."},
+      "insertText": "filter { ${1:element} in\n\t$0\n}",
+      "insertTextRules": 4,
+      "sortText": "04_function_filter"
+    },
+    {
+      "label": "reduce",
+      "kind": 1,
+      "detail": "Reduce elements",
+      "documentation": {"value": "```swift\nfunc reduce<Result>(_ initialResult: Result, _ nextPartialResult: (Result, Element) throws -> Result) rethrows -> Result\n```\nCombines all elements using the given closure."},
+      "insertText": "reduce(${1:initialResult}) { ${2:result}, ${3:element} in\n\t$0\n}",
+      "insertTextRules": 4,
+      "sortText": "04_function_reduce"
+    },
+    {
+      "label": "compactMap",
+      "kind": 1,
+      "detail": "Transform and filter nil",
+      "documentation": {"value": "```swift\nfunc compactMap<T>(_ transform: (Element) throws -> T?) rethrows -> [T]\n```\nReturns non-nil results of mapping the given closure."},
+      "insertText": "compactMap { ${1:element} in\n\t$0\n}",
+      "insertTextRules": 4,
+      "sortText": "04_function_compactMap"
+    },
+    {
+      "label": "flatMap",
+      "kind": 1,
+      "detail": "Map and flatten",
+      "documentation": {"value": "```swift\nfunc flatMap<T: Sequence>(_ transform: (Element) throws -> T) rethrows -> [T.Element]\n```\nReturns flattened results of mapping the given closure."},
+      "insertText": "flatMap { ${1:element} in\n\t$0\n}",
+      "insertTextRules": 4,
+      "sortText": "04_function_flatMap"
+    },
+    {
+      "label": "sorted",
+      "kind": 1,
+      "detail": "Sort elements",
+      "documentation": {"value": "```swift\nfunc sorted() -> [Element]\nfunc sorted(by: (Element, Element) throws -> Bool) rethrows -> [Element]\n```\nReturns the elements sorted."},
+      "insertText": "sorted()",
+      "insertTextRules": 4,
+      "sortText": "04_function_sorted"
+    },
+    {
+      "label": "forEach",
+      "kind": 1,
+      "detail": "Iterate elements",
+      "documentation": {"value": "```swift\nfunc forEach(_ body: (Element) throws -> Void) rethrows\n```\nCalls the given closure on each element."},
+      "insertText": "forEach { ${1:element} in\n\t$0\n}",
+      "insertTextRules": 4,
+      "sortText": "04_function_forEach"
+    },
+    {
+      "label": "contains",
+      "kind": 1,
+      "detail": "Check if contains element",
+      "documentation": {"value": "```swift\nfunc contains(_ element: Element) -> Bool\nfunc contains(where: (Element) throws -> Bool) rethrows -> Bool\n```\nReturns whether the sequence contains the element."},
+      "insertText": "contains(${1:element})",
+      "insertTextRules": 4,
+      "sortText": "04_function_contains"
+    },
+    {
+      "label": "first",
+      "kind": 9,
+      "detail": "First element property",
+      "documentation": {"value": "```swift\nvar first: Element?\n```\nThe first element of the collection, or nil if empty."},
+      "insertText": "first",
+      "insertTextRules": 4,
+      "sortText": "04_property_first"
+    },
+    {
+      "label": "last",
+      "kind": 9,
+      "detail": "Last element property",
+      "documentation": {"value": "```swift\nvar last: Element?\n```\nThe last element of the collection, or nil if empty."},
+      "insertText": "last",
+      "insertTextRules": 4,
+      "sortText": "04_property_last"
+    },
+    {
+      "label": "count",
+      "kind": 9,
+      "detail": "Count property",
+      "documentation": {"value": "```swift\nvar count: Int\n```\nThe number of elements in the collection."},
+      "insertText": "count",
+      "insertTextRules": 4,
+      "sortText": "04_property_count"
+    },
+    {
+      "label": "isEmpty",
+      "kind": 9,
+      "detail": "Is empty property",
+      "documentation": {"value": "```swift\nvar isEmpty: Bool\n```\nA Boolean value indicating whether the collection is empty."},
+      "insertText": "isEmpty",
+      "insertTextRules": 4,
+      "sortText": "04_property_isEmpty"
+    },
+    {
+      "label": "append",
+      "kind": 1,
+      "detail": "Append element",
+      "documentation": {"value": "```swift\nmutating func append(_ newElement: Element)\n```\nAdds an element to the end of the array."},
+      "insertText": "append(${1:element})",
+      "insertTextRules": 4,
+      "sortText": "04_function_append"
+    },
+    {
+      "label": "insert",
+      "kind": 1,
+      "detail": "Insert element",
+      "documentation": {"value": "```swift\nmutating func insert(_ newElement: Element, at i: Int)\n```\nInserts an element at the specified position."},
+      "insertText": "insert(${1:element}, at: ${2:index})",
+      "insertTextRules": 4,
+      "sortText": "04_function_insert"
+    },
+    {
+      "label": "remove",
+      "kind": 1,
+      "detail": "Remove element at index",
+      "documentation": {"value": "```swift\nmutating func remove(at index: Int) -> Element\n```\nRemoves and returns the element at the specified index."},
+      "insertText": "remove(at: ${1:index})",
+      "insertTextRules": 4,
+      "sortText": "04_function_remove"
+    },
+    {
+      "label": "removeAll",
+      "kind": 1,
+      "detail": "Remove all elements",
+      "documentation": {"value": "```swift\nmutating func removeAll(keepingCapacity: Bool = false)\n```\nRemoves all elements from the collection."},
+      "insertText": "removeAll()",
+      "insertTextRules": 4,
+      "sortText": "04_function_removeAll"
+    },
+    {
+      "label": "enumerated",
+      "kind": 1,
+      "detail": "Enumerated sequence",
+      "documentation": {"value": "```swift\nfunc enumerated() -> EnumeratedSequence<Self>\n```\nReturns pairs of (offset, element)."},
+      "insertText": "enumerated()",
+      "insertTextRules": 4,
+      "sortText": "04_function_enumerated"
+    },
+    {
+      "label": "prefix",
+      "kind": 1,
+      "detail": "Get prefix of collection",
+      "documentation": {"value": "```swift\nfunc prefix(_ maxLength: Int) -> Slice<Self>\n```\nReturns the first maxLength elements."},
+      "insertText": "prefix(${1:maxLength})",
+      "insertTextRules": 4,
+      "sortText": "04_function_prefix"
+    },
+    {
+      "label": "suffix",
+      "kind": 1,
+      "detail": "Get suffix of collection",
+      "documentation": {"value": "```swift\nfunc suffix(_ maxLength: Int) -> Slice<Self>\n```\nReturns the last maxLength elements."},
+      "insertText": "suffix(${1:maxLength})",
+      "insertTextRules": 4,
+      "sortText": "04_function_suffix"
+    },
+    {
+      "label": "joined",
+      "kind": 1,
+      "detail": "Join elements",
+      "documentation": {"value": "```swift\nfunc joined(separator: String = \"\") -> String\n```\nJoins string elements with a separator."},
+      "insertText": "joined(separator: ${1:\", \"})",
+      "insertTextRules": 4,
+      "sortText": "04_function_joined"
+    },
+    {
+      "label": "split",
+      "kind": 1,
+      "detail": "Split string",
+      "documentation": {"value": "```swift\nfunc split(separator: Character, maxSplits: Int = .max, omittingEmptySubsequences: Bool = true) -> [Substring]\n```\nSplits a string by the given separator."},
+      "insertText": "split(separator: ${1:separator})",
+      "insertTextRules": 4,
+      "sortText": "04_function_split"
+    },
+    {
+      "label": "replacingOccurrences",
+      "kind": 1,
+      "detail": "Replace occurrences in string",
+      "documentation": {"value": "```swift\nfunc replacingOccurrences(of target: String, with replacement: String) -> String\n```\nReturns a new string replacing all occurrences of target."},
+      "insertText": "replacingOccurrences(of: ${1:target}, with: ${2:replacement})",
+      "insertTextRules": 4,
+      "sortText": "04_function_replacingOccurrences"
+    },
+    {
+      "label": "hasPrefix",
+      "kind": 1,
+      "detail": "Check string prefix",
+      "documentation": {"value": "```swift\nfunc hasPrefix(_ prefix: String) -> Bool\n```\nReturns whether the string begins with the specified prefix."},
+      "insertText": "hasPrefix(${1:prefix})",
+      "insertTextRules": 4,
+      "sortText": "04_function_hasPrefix"
+    },
+    {
+      "label": "hasSuffix",
+      "kind": 1,
+      "detail": "Check string suffix",
+      "documentation": {"value": "```swift\nfunc hasSuffix(_ suffix: String) -> Bool\n```\nReturns whether the string ends with the specified suffix."},
+      "insertText": "hasSuffix(${1:suffix})",
+      "insertTextRules": 4,
+      "sortText": "04_function_hasSuffix"
+    },
+    {
+      "label": "uppercased",
+      "kind": 1,
+      "detail": "Uppercase string",
+      "documentation": {"value": "```swift\nfunc uppercased() -> String\n```\nReturns an uppercased version of the string."},
+      "insertText": "uppercased()",
+      "insertTextRules": 4,
+      "sortText": "04_function_uppercased"
+    },
+    {
+      "label": "lowercased",
+      "kind": 1,
+      "detail": "Lowercase string",
+      "documentation": {"value": "```swift\nfunc lowercased() -> String\n```\nReturns a lowercased version of the string."},
+      "insertText": "lowercased()",
+      "insertTextRules": 4,
+      "sortText": "04_function_lowercased"
+    },
+    {
+      "label": "trimmingCharacters",
+      "kind": 1,
+      "detail": "Trim characters",
+      "documentation": {"value": "```swift\nfunc trimmingCharacters(in set: CharacterSet) -> String\n```\nReturns a string with characters in the given set trimmed."},
+      "insertText": "trimmingCharacters(in: .${1:whitespaces})",
+      "insertTextRules": 4,
+      "sortText": "04_function_trimmingCharacters"
+    },
+    {
+      "label": "Int",
+      "kind": 6,
+      "detail": "Integer type",
+      "documentation": {"value": "```swift\nstruct Int: FixedWidthInteger, SignedInteger\n```\nA signed integer value type."},
+      "insertText": "Int",
+      "insertTextRules": 4,
+      "sortText": "05_type_Int"
+    },
+    {
+      "label": "Double",
+      "kind": 6,
+      "detail": "Double-precision floating point",
+      "documentation": {"value": "```swift\nstruct Double: FloatingPoint\n```\nA double-precision, floating-point value type."},
+      "insertText": "Double",
+      "insertTextRules": 4,
+      "sortText": "05_type_Double"
+    },
+    {
+      "label": "Float",
+      "kind": 6,
+      "detail": "Single-precision floating point",
+      "documentation": {"value": "```swift\nstruct Float: FloatingPoint\n```\nA single-precision, floating-point value type."},
+      "insertText": "Float",
+      "insertTextRules": 4,
+      "sortText": "05_type_Float"
+    },
+    {
+      "label": "String",
+      "kind": 6,
+      "detail": "String type",
+      "documentation": {"value": "```swift\nstruct String: StringProtocol\n```\nA Unicode string value."},
+      "insertText": "String",
+      "insertTextRules": 4,
+      "sortText": "05_type_String"
+    },
+    {
+      "label": "Bool",
+      "kind": 6,
+      "detail": "Boolean type",
+      "documentation": {"value": "```swift\nstruct Bool\n```\nA value type whose instances are either true or false."},
+      "insertText": "Bool",
+      "insertTextRules": 4,
+      "sortText": "05_type_Bool"
+    },
+    {
+      "label": "Array",
+      "kind": 6,
+      "detail": "Array type",
+      "documentation": {"value": "```swift\nstruct Array<Element>: RandomAccessCollection, MutableCollection\n```\nAn ordered, random-access collection."},
+      "insertText": "Array<${1:Element}>",
+      "insertTextRules": 4,
+      "sortText": "05_type_Array"
+    },
+    {
+      "label": "Dictionary",
+      "kind": 6,
+      "detail": "Dictionary type",
+      "documentation": {"value": "```swift\nstruct Dictionary<Key: Hashable, Value>: Collection\n```\nA collection of key-value pairs."},
+      "insertText": "Dictionary<${1:Key}, ${2:Value}>",
+      "insertTextRules": 4,
+      "sortText": "05_type_Dictionary"
+    },
+    {
+      "label": "Set",
+      "kind": 6,
+      "detail": "Set type",
+      "documentation": {"value": "```swift\nstruct Set<Element: Hashable>: Collection\n```\nAn unordered collection of unique elements."},
+      "insertText": "Set<${1:Element}>",
+      "insertTextRules": 4,
+      "sortText": "05_type_Set"
+    },
+    {
+      "label": "Optional",
+      "kind": 15,
+      "detail": "Optional type",
+      "documentation": {"value": "```swift\nenum Optional<Wrapped>: ExpressibleByNilLiteral\n```\nA type that represents either a wrapped value or nil."},
+      "insertText": "Optional<${1:Wrapped}>",
+      "insertTextRules": 4,
+      "sortText": "05_type_Optional"
+    },
+    {
+      "label": "Result",
+      "kind": 15,
+      "detail": "Result type",
+      "documentation": {"value": "```swift\nenum Result<Success, Failure: Error>\n```\nA value that represents either a success or a failure."},
+      "insertText": "Result<${1:Success}, ${2:Failure}>",
+      "insertTextRules": 4,
+      "sortText": "05_type_Result"
+    },
+    {
+      "label": "Character",
+      "kind": 6,
+      "detail": "Character type",
+      "documentation": {"value": "```swift\nstruct Character\n```\nA single extended grapheme cluster."},
+      "insertText": "Character",
+      "insertTextRules": 4,
+      "sortText": "05_type_Character"
+    },
+    {
+      "label": "UInt",
+      "kind": 6,
+      "detail": "Unsigned integer type",
+      "documentation": {"value": "```swift\nstruct UInt: FixedWidthInteger, UnsignedInteger\n```\nAn unsigned integer value type."},
+      "insertText": "UInt",
+      "insertTextRules": 4,
+      "sortText": "05_type_UInt"
+    },
+    {
+      "label": "Int8",
+      "kind": 6,
+      "detail": "8-bit signed integer",
+      "documentation": {"value": "An 8-bit signed integer type."},
+      "insertText": "Int8",
+      "insertTextRules": 4,
+      "sortText": "05_type_Int8"
+    },
+    {
+      "label": "Int16",
+      "kind": 6,
+      "detail": "16-bit signed integer",
+      "documentation": {"value": "A 16-bit signed integer type."},
+      "insertText": "Int16",
+      "insertTextRules": 4,
+      "sortText": "05_type_Int16"
+    },
+    {
+      "label": "Int32",
+      "kind": 6,
+      "detail": "32-bit signed integer",
+      "documentation": {"value": "A 32-bit signed integer type."},
+      "insertText": "Int32",
+      "insertTextRules": 4,
+      "sortText": "05_type_Int32"
+    },
+    {
+      "label": "Int64",
+      "kind": 6,
+      "detail": "64-bit signed integer",
+      "documentation": {"value": "A 64-bit signed integer type."},
+      "insertText": "Int64",
+      "insertTextRules": 4,
+      "sortText": "05_type_Int64"
+    },
+    {
+      "label": "Data",
+      "kind": 6,
+      "detail": "Raw data type",
+      "documentation": {"value": "```swift\nstruct Data: Collection\n```\nA byte buffer in memory."},
+      "insertText": "Data",
+      "insertTextRules": 4,
+      "sortText": "05_type_Data"
+    },
+    {
+      "label": "URL",
+      "kind": 6,
+      "detail": "URL type",
+      "documentation": {"value": "```swift\nstruct URL: Hashable\n```\nA value that identifies the location of a resource."},
+      "insertText": "URL",
+      "insertTextRules": 4,
+      "sortText": "05_type_URL"
+    },
+    {
+      "label": "Date",
+      "kind": 6,
+      "detail": "Date type",
+      "documentation": {"value": "```swift\nstruct Date: Comparable, Hashable\n```\nA specific point in time."},
+      "insertText": "Date",
+      "insertTextRules": 4,
+      "sortText": "05_type_Date"
+    },
+    {
+      "label": "Error",
+      "kind": 7,
+      "detail": "Error protocol",
+      "documentation": {"value": "```swift\nprotocol Error\n```\nA type representing an error value that can be thrown."},
+      "insertText": "Error",
+      "insertTextRules": 4,
+      "sortText": "05_type_Error"
+    },
+    {
+      "label": "Codable",
+      "kind": 7,
+      "detail": "Codable protocol",
+      "documentation": {"value": "```swift\ntypealias Codable = Decodable & Encodable\n```\nA type that can convert itself to/from external representations."},
+      "insertText": "Codable",
+      "insertTextRules": 4,
+      "sortText": "05_type_Codable"
+    },
+    {
+      "label": "Hashable",
+      "kind": 7,
+      "detail": "Hashable protocol",
+      "documentation": {"value": "```swift\nprotocol Hashable: Equatable\n```\nA type that can be hashed into a Hasher to produce an integer hash value."},
+      "insertText": "Hashable",
+      "insertTextRules": 4,
+      "sortText": "05_type_Hashable"
+    },
+    {
+      "label": "Equatable",
+      "kind": 7,
+      "detail": "Equatable protocol",
+      "documentation": {"value": "```swift\nprotocol Equatable\n```\nA type that can be compared for value equality."},
+      "insertText": "Equatable",
+      "insertTextRules": 4,
+      "sortText": "05_type_Equatable"
+    },
+    {
+      "label": "Comparable",
+      "kind": 7,
+      "detail": "Comparable protocol",
+      "documentation": {"value": "```swift\nprotocol Comparable: Equatable\n```\nA type that can be compared using relational operators."},
+      "insertText": "Comparable",
+      "insertTextRules": 4,
+      "sortText": "05_type_Comparable"
+    },
+    {
+      "label": "Identifiable",
+      "kind": 7,
+      "detail": "Identifiable protocol",
+      "documentation": {"value": "```swift\nprotocol Identifiable {\n    associatedtype ID: Hashable\n    var id: ID { get }\n}\n```\nA class of types with a stable identity."},
+      "insertText": "Identifiable",
+      "insertTextRules": 4,
+      "sortText": "05_type_Identifiable"
+    },
+    {
+      "label": "Sendable",
+      "kind": 7,
+      "detail": "Sendable protocol",
+      "documentation": {"value": "```swift\nprotocol Sendable\n```\nA type whose values can safely be passed across concurrency domains."},
+      "insertText": "Sendable",
+      "insertTextRules": 4,
+      "sortText": "05_type_Sendable"
+    },
+    {
+      "label": "AsyncSequence",
+      "kind": 7,
+      "detail": "AsyncSequence protocol",
+      "documentation": {"value": "```swift\nprotocol AsyncSequence\n```\nA type providing asynchronous, sequential, iterated access to its elements."},
+      "insertText": "AsyncSequence",
+      "insertTextRules": 4,
+      "sortText": "05_type_AsyncSequence"
+    },
+    {
+      "label": "Task",
+      "kind": 6,
+      "detail": "Concurrency Task",
+      "documentation": {"value": "```swift\nstruct Task<Success: Sendable, Failure: Error>\n```\nA unit of asynchronous work."},
+      "insertText": "Task {\n\t$0\n}",
+      "insertTextRules": 4,
+      "sortText": "05_type_Task"
+    },
+    {
+      "label": "if let",
+      "kind": 28,
+      "detail": "Optional binding snippet",
+      "documentation": {"value": "```swift\nif let value = optional {\n    // use value\n}\n```\nSafely unwraps an optional."},
+      "insertText": "if let ${1:value} = ${2:optional} {\n\t$0\n}",
+      "insertTextRules": 4,
+      "sortText": "06_snippet_if_let"
+    },
+    {
+      "label": "guard let",
+      "kind": 28,
+      "detail": "Guard let snippet",
+      "documentation": {"value": "```swift\nguard let value = optional else {\n    return\n}\n```\nEarly exit guard with optional binding."},
+      "insertText": "guard let ${1:value} = ${2:optional} else {\n\t${3:return}\n}",
+      "insertTextRules": 4,
+      "sortText": "06_snippet_guard_let"
+    },
+    {
+      "label": "do-catch",
+      "kind": 28,
+      "detail": "Do-catch snippet",
+      "documentation": {"value": "```swift\ndo {\n    try expression\n} catch {\n    print(error)\n}\n```\nError handling block."},
+      "insertText": "do {\n\ttry ${1:expression}\n} catch {\n\t${2:print(error)}\n}",
+      "insertTextRules": 4,
+      "sortText": "06_snippet_do_catch"
+    },
+    {
+      "label": "for-in",
+      "kind": 28,
+      "detail": "For-in loop snippet",
+      "documentation": {"value": "```swift\nfor item in collection {\n    // body\n}\n```\nIterate over a sequence."},
+      "insertText": "for ${1:item} in ${2:collection} {\n\t$0\n}",
+      "insertTextRules": 4,
+      "sortText": "06_snippet_for_in"
+    },
+    {
+      "label": "switch-enum",
+      "kind": 28,
+      "detail": "Switch on enum snippet",
+      "documentation": {"value": "```swift\nswitch value {\ncase .case1:\n    break\ncase .case2:\n    break\n}\n```\nExhaustive switch on enum."},
+      "insertText": "switch ${1:value} {\ncase .${2:case1}:\n\t${3:break}\ncase .${4:case2}:\n\t${5:break}\n}",
+      "insertTextRules": 4,
+      "sortText": "06_snippet_switch_enum"
+    },
+    {
+      "label": "closure",
+      "kind": 28,
+      "detail": "Closure snippet",
+      "documentation": {"value": "```swift\n{ (param: Type) -> ReturnType in\n    // body\n}\n```\nClosure expression."},
+      "insertText": "{ (${1:params}) -> ${2:Void} in\n\t$0\n}",
+      "insertTextRules": 4,
+      "sortText": "06_snippet_closure"
+    },
+    {
+      "label": "async-func",
+      "kind": 28,
+      "detail": "Async function snippet",
+      "documentation": {"value": "```swift\nfunc name() async throws -> Type {\n    // body\n}\n```\nAsync throwing function."},
+      "insertText": "func ${1:name}(${2:params}) async throws -> ${3:Void} {\n\t$0\n}",
+      "insertTextRules": 4,
+      "sortText": "06_snippet_async_func"
+    },
+    {
+      "label": "struct-codable",
+      "kind": 28,
+      "detail": "Codable struct snippet",
+      "documentation": {"value": "```swift\nstruct Name: Codable {\n    let property: Type\n}\n```\nCodable struct for JSON decoding."},
+      "insertText": "struct ${1:Name}: Codable {\n\tlet ${2:property}: ${3:Type}\n}",
+      "insertTextRules": 4,
+      "sortText": "06_snippet_struct_codable"
+    },
+    {
+      "label": "swiftui-view",
+      "kind": 28,
+      "detail": "SwiftUI View snippet",
+      "documentation": {"value": "```swift\nstruct MyView: View {\n    var body: some View {\n        Text(\"Hello\")\n    }\n}\n```\nSwiftUI view declaration."},
+      "insertText": "struct ${1:MyView}: View {\n\tvar body: some View {\n\t\t${2:Text(\"Hello\")}\n\t}\n}",
+      "insertTextRules": 4,
+      "sortText": "06_snippet_swiftui_view"
+    },
+    {
+      "label": "enum-error",
+      "kind": 28,
+      "detail": "Error enum snippet",
+      "documentation": {"value": "```swift\nenum MyError: Error {\n    case notFound\n    case invalidInput(String)\n}\n```\nCustom error type."},
+      "insertText": "enum ${1:MyError}: Error {\n\tcase ${2:someError}\n\tcase ${3:otherError}(${4:String})\n}",
+      "insertTextRules": 4,
+      "sortText": "06_snippet_enum_error"
+    },
+    {
+      "label": "protocol-default",
+      "kind": 28,
+      "detail": "Protocol with default implementation snippet",
+      "documentation": {"value": "Protocol with extension providing default implementation."},
+      "insertText": "protocol ${1:Name} {\n\tfunc ${2:method}()\n}\n\nextension ${1:Name} {\n\tfunc ${2:method}() {\n\t\t$0\n\t}\n}",
+      "insertTextRules": 4,
+      "sortText": "06_snippet_protocol_default"
+    },
+    {
+      "label": "task-group",
+      "kind": 28,
+      "detail": "Task group snippet",
+      "documentation": {"value": "```swift\nawait withTaskGroup(of: Type.self) { group in\n    group.addTask { ... }\n}\n```\nStructured concurrency task group."},
+      "insertText": "await withTaskGroup(of: ${1:Type}.self) { group in\n\tgroup.addTask {\n\t\t$0\n\t}\n}",
+      "insertTextRules": 4,
+      "sortText": "06_snippet_task_group"
+    },
+    {
+      "label": "Void",
+      "kind": 6,
+      "detail": "Void type",
+      "documentation": {"value": "```swift\ntypealias Void = ()\n```\nThe empty tuple type, used for functions that return nothing."},
+      "insertText": "Void",
+      "insertTextRules": 4,
+      "sortText": "05_type_Void"
+    },
+    {
+      "label": "Never",
+      "kind": 15,
+      "detail": "Never type",
+      "documentation": {"value": "```swift\nenum Never\n```\nA type with no values; used for functions that never return."},
+      "insertText": "Never",
+      "insertTextRules": 4,
+      "sortText": "05_type_Never"
+    },
+    {
+      "label": "Any",
+      "kind": 17,
+      "detail": "Any type",
+      "documentation": {"value": "The protocol to which all types implicitly conform."},
+      "insertText": "Any",
+      "insertTextRules": 4,
+      "sortText": "05_type_Any"
+    },
+    {
+      "label": "AnyObject",
+      "kind": 7,
+      "detail": "AnyObject protocol",
+      "documentation": {"value": "The protocol to which all classes implicitly conform."},
+      "insertText": "AnyObject",
+      "insertTextRules": 4,
+      "sortText": "05_type_AnyObject"
+    },
+    {
+      "label": "Range",
+      "kind": 6,
+      "detail": "Half-open range type",
+      "documentation": {"value": "```swift\nstruct Range<Bound: Comparable>\n```\nA half-open interval from a lower bound up to, but not including, an upper bound."},
+      "insertText": "Range<${1:Int}>",
+      "insertTextRules": 4,
+      "sortText": "05_type_Range"
+    },
+    {
+      "label": "ClosedRange",
+      "kind": 6,
+      "detail": "Closed range type",
+      "documentation": {"value": "```swift\nstruct ClosedRange<Bound: Comparable>\n```\nAn interval from a lower bound up to, and including, an upper bound."},
+      "insertText": "ClosedRange<${1:Int}>",
+      "insertTextRules": 4,
+      "sortText": "05_type_ClosedRange"
+    },
+    {
+      "label": "true",
+      "kind": 14,
+      "detail": "Boolean true",
+      "documentation": {"value": "Boolean literal true."},
+      "insertText": "true",
+      "insertTextRules": 4,
+      "sortText": "07_constant_true"
+    },
+    {
+      "label": "false",
+      "kind": 14,
+      "detail": "Boolean false",
+      "documentation": {"value": "Boolean literal false."},
+      "insertText": "false",
+      "insertTextRules": 4,
+      "sortText": "07_constant_false"
+    },
+    {
+      "label": "nil",
+      "kind": 14,
+      "detail": "Nil literal",
+      "documentation": {"value": "The absence of a value for optional types."},
+      "insertText": "nil",
+      "insertTextRules": 4,
+      "sortText": "07_constant_nil"
+    },
+    {
+      "label": "Foundation",
+      "kind": 8,
+      "detail": "Foundation framework",
+      "documentation": {"value": "```swift\nimport Foundation\n```\nApple's base framework for essential data types, collections, and OS services."},
+      "insertText": "Foundation",
+      "insertTextRules": 4,
+      "sortText": "08_module_Foundation"
+    },
+    {
+      "label": "SwiftUI",
+      "kind": 8,
+      "detail": "SwiftUI framework",
+      "documentation": {"value": "```swift\nimport SwiftUI\n```\nApple's declarative UI framework."},
+      "insertText": "SwiftUI",
+      "insertTextRules": 4,
+      "sortText": "08_module_SwiftUI"
+    },
+    {
+      "label": "Combine",
+      "kind": 8,
+      "detail": "Combine framework",
+      "documentation": {"value": "```swift\nimport Combine\n```\nApple's reactive programming framework."},
+      "insertText": "Combine",
+      "insertTextRules": 4,
+      "sortText": "08_module_Combine"
+    },
+    {
+      "label": "UIKit",
+      "kind": 8,
+      "detail": "UIKit framework",
+      "documentation": {"value": "```swift\nimport UIKit\n```\nApple's imperative UI framework for iOS/tvOS."},
+      "insertText": "UIKit",
+      "insertTextRules": 4,
+      "sortText": "08_module_UIKit"
+    },
+    {
+      "label": "@objc",
+      "kind": 17,
+      "detail": "Objective-C attribute",
+      "documentation": {"value": "Exposes the declaration to Objective-C runtime."},
+      "insertText": "@objc ",
+      "insertTextRules": 4,
+      "sortText": "03_attribute_objc"
+    },
+    {
+      "label": "@discardableResult",
+      "kind": 17,
+      "detail": "Discardable result attribute",
+      "documentation": {"value": "Suppresses the unused result warning."},
+      "insertText": "@discardableResult\n",
+      "insertTextRules": 4,
+      "sortText": "03_attribute_discardableResult"
+    },
+    {
+      "label": "@available",
+      "kind": 17,
+      "detail": "Availability attribute",
+      "documentation": {"value": "```swift\n@available(iOS 15.0, macOS 12.0, *)\n```\nSpecifies platform availability."},
+      "insertText": "@available(${1:iOS 15.0}, *)\n",
+      "insertTextRules": 4,
+      "sortText": "03_attribute_available"
+    },
+    {
+      "label": "@escaping",
+      "kind": 17,
+      "detail": "Escaping closure attribute",
+      "documentation": {"value": "Marks a closure parameter that may outlive the function call."},
+      "insertText": "@escaping ",
+      "insertTextRules": 4,
+      "sortText": "03_attribute_escaping"
+    },
+    {
+      "label": "@Environment",
+      "kind": 17,
+      "detail": "Environment property wrapper",
+      "documentation": {"value": "```swift\n@Environment(\\.colorScheme) var colorScheme\n```\nReads a value from the SwiftUI environment."},
+      "insertText": "@Environment(\\.${1:keyPath}) var ${2:name}",
+      "insertTextRules": 4,
+      "sortText": "03_attribute_Environment"
+    },
+    {
+      "label": "@StateObject",
+      "kind": 17,
+      "detail": "StateObject property wrapper",
+      "documentation": {"value": "```swift\n@StateObject var model = ViewModel()\n```\nCreates and manages an observable object in SwiftUI."},
+      "insertText": "@StateObject var ${1:name} = ${2:ViewModel}()",
+      "insertTextRules": 4,
+      "sortText": "03_attribute_StateObject"
+    },
+    {
+      "label": "@ObservedObject",
+      "kind": 17,
+      "detail": "ObservedObject property wrapper",
+      "documentation": {"value": "```swift\n@ObservedObject var model: ViewModel\n```\nObserves an external observable object."},
+      "insertText": "@ObservedObject var ${1:name}: ${2:ViewModel}",
+      "insertTextRules": 4,
+      "sortText": "03_attribute_ObservedObject"
+    },
+    {
+      "label": "@EnvironmentObject",
+      "kind": 17,
+      "detail": "EnvironmentObject property wrapper",
+      "documentation": {"value": "Reads a shared observable object from the environment."},
+      "insertText": "@EnvironmentObject var ${1:name}: ${2:Type}",
+      "insertTextRules": 4,
+      "sortText": "03_attribute_EnvironmentObject"
+    },
+    {
+      "label": "Decodable",
+      "kind": 7,
+      "detail": "Decodable protocol",
+      "documentation": {"value": "```swift\nprotocol Decodable\n```\nA type that can decode itself from an external representation."},
+      "insertText": "Decodable",
+      "insertTextRules": 4,
+      "sortText": "05_type_Decodable"
+    },
+    {
+      "label": "Encodable",
+      "kind": 7,
+      "detail": "Encodable protocol",
+      "documentation": {"value": "```swift\nprotocol Encodable\n```\nA type that can encode itself to an external representation."},
+      "insertText": "Encodable",
+      "insertTextRules": 4,
+      "sortText": "05_type_Encodable"
+    },
+    {
+      "label": "CustomStringConvertible",
+      "kind": 7,
+      "detail": "CustomStringConvertible protocol",
+      "documentation": {"value": "A type with a customized textual representation via the description property."},
+      "insertText": "CustomStringConvertible",
+      "insertTextRules": 4,
+      "sortText": "05_type_CustomStringConvertible"
+    },
+    {
+      "label": "Sequence",
+      "kind": 7,
+      "detail": "Sequence protocol",
+      "documentation": {"value": "A type providing sequential, iterated access to its elements."},
+      "insertText": "Sequence",
+      "insertTextRules": 4,
+      "sortText": "05_type_Sequence"
+    },
+    {
+      "label": "Collection",
+      "kind": 7,
+      "detail": "Collection protocol",
+      "documentation": {"value": "A sequence whose elements can be traversed multiple times and accessed by indexed subscript."},
+      "insertText": "Collection",
+      "insertTextRules": 4,
+      "sortText": "05_type_Collection"
+    },
+    {
+      "label": "AnyHashable",
+      "kind": 6,
+      "detail": "Type-erased hashable value",
+      "documentation": {"value": "A type-erased hashable value."},
+      "insertText": "AnyHashable",
+      "insertTextRules": 4,
+      "sortText": "05_type_AnyHashable"
+    },
+    {
+      "label": "Substring",
+      "kind": 6,
+      "detail": "Substring type",
+      "documentation": {"value": "A slice of a string. Shares storage with the original String."},
+      "insertText": "Substring",
+      "insertTextRules": 4,
+      "sortText": "05_type_Substring"
+    },
+    {
+      "label": "UInt8",
+      "kind": 6,
+      "detail": "8-bit unsigned integer",
+      "documentation": {"value": "An 8-bit unsigned integer type."},
+      "insertText": "UInt8",
+      "insertTextRules": 4,
+      "sortText": "05_type_UInt8"
+    },
+    {
+      "label": "UInt16",
+      "kind": 6,
+      "detail": "16-bit unsigned integer",
+      "documentation": {"value": "A 16-bit unsigned integer type."},
+      "insertText": "UInt16",
+      "insertTextRules": 4,
+      "sortText": "05_type_UInt16"
+    },
+    {
+      "label": "UInt32",
+      "kind": 6,
+      "detail": "32-bit unsigned integer",
+      "documentation": {"value": "A 32-bit unsigned integer type."},
+      "insertText": "UInt32",
+      "insertTextRules": 4,
+      "sortText": "05_type_UInt32"
+    },
+    {
+      "label": "UInt64",
+      "kind": 6,
+      "detail": "64-bit unsigned integer",
+      "documentation": {"value": "A 64-bit unsigned integer type."},
+      "insertText": "UInt64",
+      "insertTextRules": 4,
+      "sortText": "05_type_UInt64"
+    },
+    {
+      "label": "#selector",
+      "kind": 17,
+      "detail": "Selector expression",
+      "documentation": {"value": "```swift\n#selector(MyClass.method)\n```\nRefers to an Objective-C selector."},
+      "insertText": "#selector(${1:method})",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_selector"
+    },
+    {
+      "label": "#if",
+      "kind": 17,
+      "detail": "Conditional compilation",
+      "documentation": {"value": "```swift\n#if os(iOS)\n    // iOS-specific code\n#endif\n```\nConditional compilation block."},
+      "insertText": "#if ${1:condition}\n$0\n#endif",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_if_directive"
+    },
+    {
+      "label": "precondition",
+      "kind": 1,
+      "detail": "Precondition check",
+      "documentation": {"value": "```swift\nfunc precondition(_ condition: @autoclosure () -> Bool, _ message: @autoclosure () -> String = \"\", file: StaticString = #file, line: UInt = #line)\n```\nChecks a necessary condition for making forward progress."},
+      "insertText": "precondition(${1:condition}, ${2:\"message\"})",
+      "insertTextRules": 4,
+      "sortText": "04_function_precondition"
+    },
+    {
+      "label": "assert",
+      "kind": 1,
+      "detail": "Debug assertion",
+      "documentation": {"value": "```swift\nfunc assert(_ condition: @autoclosure () -> Bool, _ message: @autoclosure () -> String = \"\")\n```\nPerforms a debug-only assertion."},
+      "insertText": "assert(${1:condition}, ${2:\"message\"})",
+      "insertTextRules": 4,
+      "sortText": "04_function_assert"
+    },
+    {
+      "label": "fatalError",
+      "kind": 1,
+      "detail": "Fatal error",
+      "documentation": {"value": "```swift\nfunc fatalError(_ message: @autoclosure () -> String = \"\", file: StaticString = #file, line: UInt = #line) -> Never\n```\nUnconditionally stops execution with a message."},
+      "insertText": "fatalError(${1:\"message\"})",
+      "insertTextRules": 4,
+      "sortText": "04_function_fatalError"
+    },
+    {
+      "label": "type(of:)",
+      "kind": 1,
+      "detail": "Get dynamic type",
+      "documentation": {"value": "```swift\nfunc type<T>(of value: T) -> T.Type\n```\nReturns the dynamic type of a value."},
+      "insertText": "type(of: ${1:value})",
+      "insertTextRules": 4,
+      "sortText": "04_function_typeOf"
+    },
+    {
+      "label": "withAnimation",
+      "kind": 1,
+      "detail": "SwiftUI animation wrapper",
+      "documentation": {"value": "```swift\nwithAnimation(.default) {\n    // state changes\n}\n```\nWraps state changes in an animation."},
+      "insertText": "withAnimation(${1:.default}) {\n\t$0\n}",
+      "insertTextRules": 4,
+      "sortText": "04_function_withAnimation"
+    },
+    {
+      "label": "DispatchQueue",
+      "kind": 5,
+      "detail": "Grand Central Dispatch queue",
+      "documentation": {"value": "```swift\nclass DispatchQueue\n```\nManages the execution of work items on a serial or concurrent queue."},
+      "insertText": "DispatchQueue.${1:main}.${2:async} {\n\t$0\n}",
+      "insertTextRules": 4,
+      "sortText": "05_type_DispatchQueue"
+    },
+    {
+      "label": "JSONDecoder",
+      "kind": 5,
+      "detail": "JSON decoder",
+      "documentation": {"value": "```swift\nlet decoder = JSONDecoder()\nlet value = try decoder.decode(Type.self, from: data)\n```\nDecodes JSON data into Swift types."},
+      "insertText": "JSONDecoder()",
+      "insertTextRules": 4,
+      "sortText": "05_type_JSONDecoder"
+    },
+    {
+      "label": "JSONEncoder",
+      "kind": 5,
+      "detail": "JSON encoder",
+      "documentation": {"value": "```swift\nlet encoder = JSONEncoder()\nlet data = try encoder.encode(value)\n```\nEncodes Swift types to JSON data."},
+      "insertText": "JSONEncoder()",
+      "insertTextRules": 4,
+      "sortText": "05_type_JSONEncoder"
+    },
+    {
+      "label": "URLSession",
+      "kind": 5,
+      "detail": "URL session",
+      "documentation": {"value": "```swift\nclass URLSession\n```\nCoordinates a group of network data transfer tasks."},
+      "insertText": "URLSession.shared",
+      "insertTextRules": 4,
+      "sortText": "05_type_URLSession"
+    },
+    {
+      "label": "NotificationCenter",
+      "kind": 5,
+      "detail": "Notification center",
+      "documentation": {"value": "A notification dispatch mechanism for broadcasting information."},
+      "insertText": "NotificationCenter.default",
+      "insertTextRules": 4,
+      "sortText": "05_type_NotificationCenter"
+    },
+    {
+      "label": "UserDefaults",
+      "kind": 5,
+      "detail": "User defaults storage",
+      "documentation": {"value": "An interface to the user's defaults database for persistent storage."},
+      "insertText": "UserDefaults.standard",
+      "insertTextRules": 4,
+      "sortText": "05_type_UserDefaults"
+    },
+    {
+      "label": "Tuple",
+      "kind": 6,
+      "detail": "Tuple type",
+      "documentation": {"value": "```swift\nlet pair: (String, Int) = (\"hello\", 42)\n```\nA fixed-size group of values of different types."},
+      "insertText": "(${1:Type1}, ${2:Type2})",
+      "insertTextRules": 4,
+      "sortText": "05_type_Tuple"
+    }
+  ]
+}