Add lualibImport require-minimal documentation and removed old deprecated annotations list

Author: Perryvw

docs/advanced/compiler-annotations.md

@@ -247,304 +247,3 @@ Indicates that functions in a file do not take in initial `self` argument when c
 This is annotation works the same as [@noSelf](#noself) being applied to a namespace, but affects the entire file.
 
 `@noSelfInFile` must be placed at the top of the file, before the first statement.
-
-## Deprecated
-
-:::warning
-Some annotations are deprecated and will be/have been removed.
-Below are the deprecated annotations and instructions to recreate their behavior with vanilla TypeScript.
-:::
-
-### @tupleReturn
-
-<DeprecatedInVersion deprecated="0.42.0" removed="0.43.0" />
-
-**Target elements:** `(declare) function`
-
-This decorator indicates a function returns a lua tuple instead of a table. It influences both destructing assignments of calls of that function, as well as changing the format of returns inside the function body.
-
-**Upgrade Instructions**
-
-Use the [`LuaMultiReturn` language extensions](language-extensions.md#luamultireturn-type) instead of a custom annotated types. This makes multi return usage type-safe and more obvious.
-
-```typescript
-/** @tupleReturn */
-function myFunction(): [number, string] {
-  return [3, "4"];
-}
-const [a, b] = myFunction();
-```
-
-Becomes:
-
-```typescript
-function myFunction(): LuaMultiReturn<[number, string]> {
-  return $multi(3, "4");
-}
-const [a, b] = myFunction();
-```
-
-Lua output:
-
-```lua
-function myFunction()
-    return 3, "4"
-end
-local a, b = myFunction()
-```
-
-### @extension
-
-<DeprecatedInVersion deprecated="0.37.0" removed="0.39.0" />
-
-**Target elements:** `class`
-
-The Extension decorator marks a class as an extension of an already existing class.
-This causes the class header to not be translated, preventing instantiation and the override of the existing class.
-
-**Upgrade Instructions**
-
-Use an interface to extend your existing class and declare the table of the existing class as variable.
-
-**Example**
-
-<SideBySide>
-
-```typescript
-interface ExistingClass {
-  myFunction(): void;
-}
-
-declare const ExistingClassTable: ExistingClass;
-
-ExistingClassTable.myFunction = function () {};
-```
-
-```lua
-function ExistingClassTable.myFunction(self) end
-```
-
-</SideBySide>
-
-### @metaExtension
-
-<DeprecatedInVersion deprecated="0.37.0" removed="0.39.0" />
-
-**Target elements:** `class`
-
-The Extension decorator marks a class as an extension of an already existing meta class/table.
-This causes the class header to not be translated, preventing instantiation and the override of the existing class.
-
-**Upgrade Instructions**
-
-Use an interface to extend your existing class and assign the functions to the meta table of the existing class.
-
-<SideBySide>
-
-```typescript
-interface MyMetaClass {
-  myFunction(): void;
-}
-
-const MyMetaClassTable: MyMetaClass = debug.getregistry().MyMetaClass as MyMetaExtension;
-
-MyMetaClassTable.myFunction = function () {};
-```
-
-```lua
-MyMetaClassTable = debug.getregistry().MyMetaClass
-MyMetaClassTable.myFunction = function(self)
-end
-```
-
-</SideBySide>
-
-### @phantom
-
-<DeprecatedInVersion deprecated="0.37.0" removed="0.39.0" />
-
-**Target elements:** `namespace`
-
-This decorator marks a namespace as a phantom namespace.
-This means all members of the namespace will be translated as if they were not in that namespace. Primarily used to prevent scoping issues.
-
-**Upgrade instructions**
-
-Use ECMAScript modules and import/export. Alternatively, use a real (non-phantom) namespace.
-
-### @pureAbstract
-
-<DeprecatedInVersion deprecated="0.37.0" removed="0.39.0" />
-
-**Target elements:** `declare class`
-
-This decorator marks a class declaration as purely abstract.
-The result is that any class extending the purely abstract class will not extend this class in the resulting Lua.
-
-**Upgrade Instructions**
-
-Try declaring the "classes" of your lua enviroment as interface.
-If that is not possible use interface merging as suggested below.
-
-<SideBySide>
-
-```typescript
-declare class MyAbstractClass {}
-interface MyClass extends MyAbstractClass {}
-
-class MyClass {}
-```
-
-```lua
-MyClass = __TS__Class()
-```
-
-</SideBySide>
-
-### @forRange
-
-<DeprecatedInVersion deprecated="0.38.0" removed="0.40.0" />
-
-**Target elements:** `declare function`
-
-Denotes a function declaration is a Lua numerical iterator. When used in a TypeScript `for...of` loop, the resulting Lua will use a numerical for loop.
-
-The function should not be a real function and an error will be thrown if it is used in any other way.
-
-**Upgrade Instructions**
-
-Use the [`$range` language extension](language-extensions.md#$range-iterator-function) instead of a custom annotated type.
-
-<SideBySide>
-
-<!-- prettier-ignore -->
-```typescript
-for (const i of $range(1, 10)) {}
-for (const i of $range(10, 1, -1)) {}
-```
-
-```lua
-for i = 1, 10 do end
-for i = 10, 1, -1 do end
-```
-
-</SideBySide>
-
-### @luaIterator
-
-<DeprecatedInVersion deprecated="0.38.1" removed="0.40.0" />
-
-**Target elements:** `(declare) interface`
-
-Denotes a type is a Lua iterator. When an object of a type with this annotation is used in a for...of statement, it will transpile directly as a lua iterator in a for...in statement, instead of being treated as a TypeScript iterable. Typically, this is used on an interface that extends `Iterable` or `Array` so that TypeScript will allow it to be used in a for...of statement.
-
-**Upgrade Instructions**
-
-Use the [`LuaIterable` and `LuaMultiReturn` language extensions](language-extensions.md#luaiterable-type) instead of a custom annotated types.
-
-<SideBySide>
-
-<!-- prettier-ignore -->
-```typescript
-declare function myIterator(): LuaIterable<string>;
-for (const s of myIterator()) {}
-```
-
-```lua
-for s in myIterator() do end
-```
-
-</SideBySide>
-
-<SideBySide>
-
-<!-- prettier-ignore -->
-```typescript
-declare namespace string {
-  function gmatch(s: string, pattern: string): LuaIterable<LuaMultiReturn<string[]>>;
-}
-
-for (const [a, b] of string.gmatch("foo", "(.)(.)")) {}
-```
-
-```lua
-for a, b in string.gmatch("foo", "(.)(.)") do end
-```
-
-</SideBySide>
-
-### @luaTable
-
-<DeprecatedInVersion deprecated="0.39.0" removed="0.40.0" />
-
-**Target elements:** `type`
-
-This annotation signals the transpiler to translate a class as a simple lua table for optimization purposes.
-
-**Upgrade Instructions**
-
-Use the [`LuaTable` language extension](language-extensions.md#lua-table-types) instead of a custom annotated type.
-
-```ts
-const tbl = new LuaTable(); // local tbl = {}
-
-const foo = {};
-tbl.set(foo, "bar"); // tbl[foo] = "bar"
-print(tbl.get(foo)); // print(tbl[foo])
-
-tbl.set(1, "baz"); // tbl[1] = "baz"
-print(tbl.length()); // print(#tbl)
-```
-
-### @vararg
-
-<DeprecatedInVersion deprecated="0.39.0" removed="0.40.0" />
-
-**Target elements:** `(declare) interface or type`
-
-Indicates that an array-like type represents a Lua vararg expression (`...`) and should be transpiled to that when used in a spread expression. This is useful for forwarding varargs instead of wrapping them in a table and unpacking them.
-
-**Upgrade Instructions**
-
-`@vararg` is no longer required to prevent vararg parameters from being wrapped in a table. The ellipsis operator will now automatically be used if the parameter is used in a spread expression.
-
-Example:
-
-<SideBySide>
-
-```ts
-function varargForward(...args: string[]) {
-  console.log(...args);
-}
-```
-
-```lua
-function varargForward(...)
-  print(...)
-end
-```
-
-</SideBySide>
-
-However, if the parameter is accessed as an array or tuple, it will be wrapped in a table.
-
-Example:
-
-<SideBySide>
-
-```ts
-function varargAccess(...args: string[]) {
-  console.log(args[0]);
-}
-```
-
-```lua
-function varargAccess(...)
-  local args = {...}
-  print(args[1])
-end
-```
-
-</SideBySide>
-
-Note that are a few cases where the parameter will still be wrapped in a table, even if a spread expression is used, in order to generate correctly functioning Lua.