lenix 1.3.0 → 1.3.2

package/Readme.md

@@ -1,6 +1,6 @@
 # lenix
 
-Helpful modules for the software engineers
+The Monorepo for the software engineering community
 
 ![](https://img.shields.io/npm/d18m/lenix)
 ![](https://img.shields.io/npm/v/lenix)
@@ -32,7 +32,7 @@ yarn add lenix
 [![](https://img.shields.io/badge/github-%23121011.svg?style=for-the-badge&logo=github&logoColor=white)](https://github.com/lenixdev/lenix)
 
 ## 🗺️ Roadmap
-- [ ]
+- [ ] fix the lint tsconfig.json file creation when no file is found
 
 ## 🧾License
 ![](https://img.shields.io/npm/l/lenix)
@@ -43,3 +43,47 @@ yarn add lenix
 ## 💻 Build with
 ![](https://img.shields.io/badge/typescript-%23007ACC.svg?style=for-the-badge&logo=typescript&logoColor=white)
 ![](https://img.shields.io/badge/node.js-%23007ACC.svg?style=for-the-badge&logo=node.js&logoColor=white)
+
+# Lua Object Oriented Programming Class Module
+
+Lua object oriented programming class module allow you to use oop similar to the TypeScript/JavaScript/Java/C++ Classes
+
+## 🗺️ Roadmap
+- [ ] Implement the complete annotation
+- [ ] Provide Documentation
+- [ ] Clearify the installation steps
+
+## Lua Modules Setup
+
+Auto-configure Lua to use `./lua_modules` (like `node_modules`) instead of unorganized directories.
+
+### Install
+- MAC
+```bash
+npx mac-lua-modules
+```
+
+### Usage
+```bash
+# Install Lua packages
+luarocks install --tree ./lua_modules inspect
+
+# Use in code (no setup needed)
+local inspect = require('inspect')
+print(inspect({name = "Lenix"}))
+```
+
+### What it does
+
+Adds environment variables to your shell config (for mac users: `~/.zshrc` or `~/.bashrc`) to automatically change your Lua modules configurations to `./lua_modules` instead of hidden nested directories.
+
+
+## ESLINT Usage
+### Build your own linter
+```zsh
+npx lenix --lint
+```
+### Clone a preset lint
+```zsh
+npx lenix --lint --preset
+```

package/{bin → lint}/dist/lint.mjs

@@ -6,7 +6,7 @@ import eslintJs from '@eslint/js';
 import tseslint from 'typescript-eslint';
 const [, , cmd, ...args] = process.argv;
 if (cmd !== '--lint') {
-    process.stdout.write('Usage: lenix --lint [--preset] [--clone]\n');
+    process.stdout.write('Usage: lenix --lint [--preset]\n');
     process.exit(0);
 }
 process.argv = [process.argv[0], process.argv[1], ...args];
@@ -207,7 +207,7 @@ if (preset) {
     const config = generateConfig(data.rules);
     fs.writeFileSync('eslint.config.mts', config, 'utf8');
     process.stdout.write(`${tag('done', c.green)} Written to ${bold('eslint.config.mts')}\n`);
-    process.stdout.write(`${tag('notice', c.cyan)} Run:  ${bold('npm add -D @eslint/js globals typescript-eslint')}\n`);
+    process.stdout.write(`${tag('notice', c.cyan)} Run: ${bold('npm add -D @eslint/js globals typescript-eslint')}\n`);
     fs.closeSync(ttyFd);
     process.exit(0);
 }

package/{bin/.eslint-preset.json → lint/lint-preset.json}

@@ -12,7 +12,10 @@
     "consistent-return": "warn",
     "consistent-this": "warn",
     "constructor-super": "warn",
-    "curly": "error",
+    "curly": [
+      "error",
+      "multi"
+    ],
     "default-case": "error",
     "default-case-last": "error",
     "default-param-last": "error",
@@ -26,14 +29,21 @@
     "grouped-accessor-pairs": "error",
     "guard-for-in": "warn",
     "id-denylist": "warn",
-    "id-length": "error",
+    "id-length": [
+      "error",
+      {
+        "exceptions": [
+          "_"
+        ]
+      }
+    ],
     "id-match": "error",
     "init-declarations": "error",
     "logical-assignment-operators": "error",
     "max-classes-per-file": "error",
     "max-depth": "error",
     "max-lines": "error",
-    "max-lines-per-function": "error",
+    "max-lines-per-function": "warn",
     "max-nested-callbacks": "error",
     "max-params": "error",
     "max-statements": "error",
@@ -48,7 +58,7 @@
     "no-class-assign": "error",
     "no-compare-neg-zero": "error",
     "no-cond-assign": "warn",
-    "no-console": "error",
+    "no-console": "warn",
     "no-const-assign": "error",
     "no-constant-binary-expression": "warn",
     "no-constant-condition": "warn",
@@ -96,7 +106,18 @@
     "no-lonely-if": "error",
     "no-loop-func": "warn",
     "no-loss-of-precision": "error",
-    "no-magic-numbers": "error",
+    "no-magic-numbers": [
+      "error",
+      {
+        "detectObjects": true,
+        "enforceConst": true,
+        "ignore": [
+          0,
+          1
+        ],
+        "ignoreReadonlyClassProperties": true
+      }
+    ],
     "no-misleading-character-class": "warn",
     "no-multi-assign": "error",
     "no-multi-str": "error",
@@ -136,9 +157,9 @@
     "no-this-before-super": "error",
     "no-throw-literal": "error",
     "no-unassigned-vars": "error",
-    "no-undef": "warn",
+    "no-undef": "error",
     "no-undef-init": "error",
-    "no-undefined": "warn",
+    "no-undefined": "off",
     "no-underscore-dangle": "warn",
     "no-unexpected-multiline": "error",
     "no-unmodified-loop-condition": "warn",
@@ -168,7 +189,7 @@
     "no-warning-comments": "warn",
     "no-with": "error",
     "object-shorthand": "error",
-    "one-var": "error",
+    "one-var": "off",
     "operator-assignment": "warn",
     "prefer-arrow-callback": "error",
     "prefer-const": "error",
@@ -189,8 +210,8 @@
     "require-await": "error",
     "require-unicode-regexp": "warn",
     "require-yield": "error",
-    "sort-imports": "warn",
-    "sort-keys": "error",
+    "sort-imports": "off",
+    "sort-keys": "off",
     "sort-vars": "error",
     "strict": "error",
     "symbol-description": "error",
@@ -211,9 +232,9 @@
     "@typescript-eslint/consistent-type-definitions": "error",
     "@typescript-eslint/consistent-type-imports": "error",
     "@typescript-eslint/default-param-last": "warn",
-    "@typescript-eslint/explicit-function-return-type": "error",
+    "@typescript-eslint/explicit-function-return-type": "off",
     "@typescript-eslint/explicit-member-accessibility": "warn",
-    "@typescript-eslint/explicit-module-boundary-types": "error",
+    "@typescript-eslint/explicit-module-boundary-types": "off",
     "@typescript-eslint/init-declarations": "error",
     "@typescript-eslint/max-params": "error",
     "@typescript-eslint/member-ordering": "error",
@@ -231,7 +252,7 @@
     "@typescript-eslint/no-inferrable-types": "error",
     "@typescript-eslint/no-invalid-void-type": "error",
     "@typescript-eslint/no-loop-func": "error",
-    "@typescript-eslint/no-magic-numbers": "warn",
+    "@typescript-eslint/no-magic-numbers": "off",
     "@typescript-eslint/no-misused-new": "error",
     "@typescript-eslint/no-namespace": "error",
     "@typescript-eslint/no-non-null-asserted-nullish-coalescing": "warn",
@@ -266,7 +287,17 @@
     "@typescript-eslint/consistent-return": "error",
     "@typescript-eslint/consistent-type-exports": "error",
     "@typescript-eslint/dot-notation": "error",
-    "@typescript-eslint/naming-convention": "warn",
+    "@typescript-eslint/naming-convention": [
+      "warn",
+      {
+        "selector": "variable",
+        "format": [
+          "camelCase",
+          "UPPER_CASE",
+          "PascalCase"
+        ]
+      }
+    ],
     "@typescript-eslint/no-array-delete": "error",
     "@typescript-eslint/no-base-to-string": "warn",
     "@typescript-eslint/no-confusing-void-expression": "error",
@@ -279,14 +310,14 @@
     "@typescript-eslint/no-misused-promises": "error",
     "@typescript-eslint/no-misused-spread": "error",
     "@typescript-eslint/no-mixed-enums": "error",
-    "@typescript-eslint/no-redundant-type-constituents": "warn",
+    "@typescript-eslint/no-redundant-type-constituents": "error",
     "@typescript-eslint/no-unnecessary-boolean-literal-compare": "error",
     "@typescript-eslint/no-unnecessary-condition": "error",
     "@typescript-eslint/no-unnecessary-qualifier": "warn",
     "@typescript-eslint/no-unnecessary-template-expression": "error",
     "@typescript-eslint/no-unnecessary-type-arguments": "error",
     "@typescript-eslint/no-unnecessary-type-assertion": "error",
-    "@typescript-eslint/no-unnecessary-type-conversion": "warn",
+    "@typescript-eslint/no-unnecessary-type-conversion": "error",
     "@typescript-eslint/no-unnecessary-type-parameters": "error",
     "@typescript-eslint/no-unsafe-argument": "error",
     "@typescript-eslint/no-unsafe-assignment": "error",
@@ -306,7 +337,12 @@
     "@typescript-eslint/prefer-optional-chain": "error",
     "@typescript-eslint/prefer-promise-reject-errors": "error",
     "@typescript-eslint/prefer-readonly": "error",
-    "@typescript-eslint/prefer-readonly-parameter-types": "error",
+    "@typescript-eslint/prefer-readonly-parameter-types": [
+      "error",
+      {
+        "ignoreInferredTypes": true
+      }
+    ],
     "@typescript-eslint/prefer-reduce-type-parameter": "error",
     "@typescript-eslint/prefer-regexp-exec": "warn",
     "@typescript-eslint/prefer-return-this-type": "error",
@@ -319,7 +355,7 @@
     "@typescript-eslint/restrict-template-expressions": "error",
     "@typescript-eslint/return-await": "error",
     "@typescript-eslint/strict-boolean-expressions": "error",
-    "@typescript-eslint/strict-void-return": "warn",
+    "@typescript-eslint/strict-void-return": "off",
     "@typescript-eslint/switch-exhaustiveness-check": "error",
     "@typescript-eslint/unbound-method": "warn",
     "@typescript-eslint/use-unknown-in-catch-callback-variable": "error"

package/{bin → lint}/lint.mts

@@ -11,7 +11,7 @@ import type { ESLint } from 'eslint'
 
 const [,, cmd, ...args] = process.argv
 if (cmd !== '--lint') {
-  process.stdout.write('Usage: lenix --lint [--preset] [--clone]\n')
+  process.stdout.write('Usage: lenix --lint [--preset]\n')
   process.exit(0)
 }
 process.argv = [process.argv[0], process.argv[1], ...args]
@@ -236,7 +236,7 @@ if (preset) {
   const config = generateConfig(data.rules)
   fs.writeFileSync('eslint.config.mts', config, 'utf8')
   process.stdout.write(`${tag('done', c.green)} Written to ${bold('eslint.config.mts')}\n`)
-  process.stdout.write(`${tag('notice', c.cyan)} Run:  ${bold('npm add -D @eslint/js globals typescript-eslint')}\n`)
+  process.stdout.write(`${tag('notice', c.cyan)} Run: ${bold('npm add -D @eslint/js globals typescript-eslint')}\n`)
   fs.closeSync(ttyFd)
   process.exit(0)
 }

package/lua/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Lenix
+
+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.

package/lua/_dev/firstAttempt.lua

@@ -0,0 +1,202 @@
+local class<const> = function (fields)
+  local defined<const> = {}
+  local private<const> = fields.private or {}
+  local getter<const> = fields.get or {}
+  local setter<const> = fields.set or {}
+  local accessor<const> = fields.accessor or {}
+  local privates<const> = { static = {}, instance = {} }
+  local setProperties<const> = { static = {}, instance = {} }
+  local getProperties<const> = { static = {}, instance = {} }
+
+  local isVariableEligible<const> = function (variable, valueType, value)
+    if defined[variable] then
+      print(("`%s` is already defined"):format(variable))
+      return
+    elseif type(value) ~= valueType and valueType ~= "any" then
+      print(("type mismatch for `%s`, expected `%s`, got `%s`"):format(variable, valueType, type(value)))
+      return
+    end
+    defined[variable] = true
+    if valueType == "any" then
+      print(("variable `%s` implicitly has type `%s`"):format(variable, valueType, type(value)))
+    end
+    return true
+  end
+
+  local fieldPairs<const> = {
+    {private, privates},
+    {getter, getProperties},
+    {setter, setProperties},
+    {accessor, nil}
+  }
+
+  for _, pair in ipairs(fieldPairs) do
+    local source, target = pair[1], pair[2]
+    for variable, values in pairs(source) do
+      -- getPropertyValue
+      local value<const> = type(values) == "table" and values[1]
+      -- getPropertyType
+      local valueType<const> = type(values) == "table" and values[2] or "any"
+      local staticValue<const> = values and values[3] or false
+      if isVariableEligible(variable, valueType, value) then
+        -- fill table with keys and values
+        if target then
+          if staticValue then
+            target["static"][variable] = value
+          else
+            target["instance"][variable] = value
+          end
+        else
+          if staticValue then
+            getProperties["static"][variable] = value
+            setProperties["static"][variable] = value
+          else
+            getProperties["instance"][variable] = value
+            setProperties["instance"][variable] = value
+          end
+        end
+      end
+    end
+  end
+
+  return setmetatable({
+    new = function (self, ...)
+      local newInstanceArgs = {...}
+      print(self)
+      local constructor<const> = fields.constructor
+      constructor(self, nil, ...)
+      return setmetatable({}, {
+        __index = function (_, variableKey)
+          if getter["instance"][variableKey] then
+            return getProperties["instance"][variableKey]
+          elseif accessor["instance"][variableKey] then
+            return getProperties["instance"][variableKey]
+          end
+        end,
+      })
+    end
+  }, {
+    __index = function(_, variableKey)
+      assert(defined[variableKey], ("property `%s` not found"):format(variableKey))
+      -- isPropertyExist
+      if getter[variableKey] ~= nil then
+        if isStatic(getter, variableKey, "get") then
+          -- returnPropertyValue
+          return getProperties["static"][variableKey]
+        end
+      elseif accessor[variableKey] ~= nil then
+        if isStatic(accessor, variableKey, "accessor") then
+          return getProperties["static"][variableKey]
+        end
+      elseif private[variableKey] ~= nil then
+        print(("cannot read the private property `%s`"):format(variableKey))
+      elseif setter[variableKey] ~= nil then
+        print(("the setter only property `%s` can not be accessed"):format(variableKey))
+      else print(("something went wrong when trying to access `%s`"):format(variableKey)) end
+    end,
+    __newindex = function (_, variableKey, variableValue)
+      assert(defined[variableKey], ("property `%s` not found"):format(variableKey))
+      if setter[variableKey] ~= nil then
+        if not isStatic(setter, variableKey, "set") then
+          local valueType = setter[variableKey][2] or "any"
+          if type(variableValue) ~= valueType and valueType ~= "any" then
+            print(("cannot assign `%s` to `%s` on `%s`"):format(type(variableValue), valueType, variableKey))
+            return
+          end
+        end
+        getProperties["static"][variableKey] = variableValue
+      elseif accessor[variableKey] ~= nil then
+        if not isStatic(accessor, variableKey, "accessor") then
+          local valueType = accessor[variableKey][2] or "any"
+          if type(variableValue) ~= valueType and valueType ~= "any" then
+            print(("cannot assign `%s` to `%s` on `%s`"):format(type(variableValue), valueType, variableKey))
+            return
+          end
+        end
+        getProperties["static"][variableKey] = variableValue
+      elseif getter[variableKey] ~= nil then
+        print(("the getter only property `%s `can not be set"):format(variableKey))
+      else print(("something went wrong when trying to access `%s`"):format(variableKey)) end
+    end
+  })
+end
+
+myClass = class({
+  private = {
+    height = {197, "number"},
+  },
+  get = {
+    blood = {"O+", "any"},
+  },
+  set = {
+    date = {2005, "number"},
+  },
+  accessor = {
+    age = {20, "number"},
+    name = {"Lenix", "string"},
+    getBlood = {function(self) return self end, "function"}
+  },
+  constructor = function(self, super, name, age)
+    self.name = name
+    self.age = age
+  end
+})
+
+
+local Person = myClass:new("Dev", 21)
+print(Person.name, Person.age)
+-- Person.date = 2005
+-- print(Person.date)
+-- print(Person.age)
+-- Person.age = 21
+
+-- print(myClass.height)
+-- print(myClass.blood)
+-- myClass.date = 2026
+-- print(myClass.age)
+-- myClass.age = 21
+-- print(myClass.age)
+-- print(myClass.name)
+-- myClass.name = "Dev"
+-- print(myClass.name)
+-- print(myClass.getBlood())
+-- myClass.getBlood = function() return true end
+-- print(myClass.getBlood())
+
+
+
+
+__index = function(_, variableKey)
+      assert(defined[variableKey], ("property `%s` not found"):format(variableKey))
+      -- isPropertyExist
+      if getter[variableKey] ~= nil then
+        -- returnPropertyValue
+        return getProperties[variableKey]
+      elseif accessor[variableKey] ~= nil then
+        return getProperties[variableKey]
+      elseif private[variableKey] ~= nil then
+        print(("cannot read the private property `%s`"):format(variableKey))
+      elseif setter[variableKey] ~= nil then
+        print(("the setter only property `%s` are forbidden to be accessed"):format(variableKey))
+      else print(("something went wrong when trying to access `%s`"):format(variableKey)) end
+    end,
+    __newindex = function (_, variableKey, variableValue)
+      assert(defined[variableKey], ("property `%s` not found"):format(variableKey))
+      if setter[variableKey] ~= nil then
+        local valueType = setter[variableKey][2] or "any"
+        if type(variableValue) ~= valueType and valueType ~= "any" then
+          print(("cannot assign `%s` to `%s` on `%s`"):format(type(variableValue), valueType, variableKey))
+          return
+        end
+        getProperties[variableKey] = variableValue
+      elseif accessor[variableKey] ~= nil then
+        local valueType = accessor[variableKey][2] or "any"
+        if type(variableValue) ~= valueType and valueType ~= "any" then
+          print(("cannot assign `%s` to `%s` on `%s`"):format(type(variableValue), valueType, variableKey))
+          return
+        end
+        getProperties[variableKey] = variableValue
+      elseif getter[variableKey] ~= nil then
+        print(("the getter only property `%s `can not be set"):format(variableKey))
+      else print(("something went wrong when trying to access `%s`"):format(variableKey)) end
+    end

package/lua/_dev/secondAttempt.lua

@@ -0,0 +1,166 @@
+assert(_VERSION == "Lua 5.4", "THIS MODULE REQUIRES Lua 5.4")
+
+local class<const> = function (fields)
+  local definedProperties<const> = {}
+  local promisedToBeConstructed<const> = {}
+  local private<const> = fields.private or {}
+  local getter<const> = fields.get or {}
+  local setter<const> = fields.set or {}
+  local accessor<const> = fields.accessor or {}
+  local privates<const> = {}
+  local setProperties<const> = {}
+  local getProperties<const> = {}
+
+  local isVariableEligible<const> = function (propertyKey, propertyType, propertyValue)
+    if definedProperties[propertyKey] then
+      print(("`%s` is already defined"):format(propertyKey))
+      return
+    elseif type(propertyValue) ~= propertyType and propertyType ~= "any" and propertyValue ~= nil then
+      error(("type mismatch for `%s`, defined `%s`, appointed `%s`"):format(propertyKey, propertyType, type(propertyValue)))
+      return
+    end
+    definedProperties[propertyKey] = true
+    if propertyType == "any" then
+      print(("variable `%s` implicitly has type `%s`"):format(propertyKey, propertyType, type(propertyValue)))
+    end
+    if propertyValue == nil and propertyType ~= "nil" then
+      promisedToBeConstructed[propertyKey] = true
+    end
+    return true
+  end
+
+  local fieldPairs<const> = {
+    {private, privates},
+    {getter, getProperties},
+    {setter, setProperties},
+    {accessor, nil}
+  }
+
+  for _, pair in ipairs(fieldPairs) do
+    local field<const>, properties<const> = pair[1], pair[2]
+    for propertyKey, propertyValues in pairs(field) do
+      -- getPropertyValue
+      local propertyValue<const> = type(propertyValues) == "table" and propertyValues[1]
+      -- getPropertyType
+      assert(type(propertyValues) == 'table', ("syntax error at `%s`, expected `%s`, got `%s`"):format(propertyKey, "table", type(propertyValues)))
+      local propertyType<const> = propertyValues[2]
+      if isVariableEligible(propertyKey, propertyType, propertyValue) then
+        -- fill table with keys and values
+        if properties then
+          properties[propertyKey] = propertyValue
+        else
+          -- for the accessor, filling the get and set permission
+          getProperties[propertyKey], setProperties[propertyKey] = propertyValue, propertyValue
+          setter[propertyKey], getter[propertyKey] = accessor[propertyKey], accessor[propertyKey]
+        end
+      end
+    end
+  end
+
+  local get<const> = function (self, propertyKey)
+    if definedProperties[propertyKey] then
+      if getter[propertyKey] then
+        if type(self[propertyKey]) == 'function' then
+          return function(...) return self[propertyKey](self, ...) end
+        end
+        return self[propertyKey]
+      elseif private[propertyKey] then
+        print(("private property `%s` is not allowed to be accessed"):format(propertyKey))
+      else print(("tried to get the `%s` set-only property"):format(propertyKey)) end
+    else
+      print(("`%s` property does not exist"):format(propertyKey))
+    end
+  end
+  local set<const> = function (self, propertyKey, propertyValue)
+    if definedProperties[propertyKey] then
+      if setter[propertyKey] then
+        if type(propertyValue) == setter[propertyKey][2] or setter[propertyKey][2] == "any" then
+          self[propertyKey] = propertyValue
+        else print(("`%s` is not assignable to `%s`: on `%s`"):format(type(propertyValue), setter[propertyKey][2], propertyKey)) end
+      elseif private[propertyKey] then
+        print(("private property `%s` is not allowed to be assigned"):format(propertyKey))
+      else print(("tried to set the `%s` get-only property"):format(propertyKey)) end
+    else
+      print(("`%s` property does not exist"):format(propertyKey))
+    end
+  end
+
+  return setmetatable({
+    new = function(self, ...)
+      local instance<const> = {}
+
+      for _, pair in pairs(fieldPairs) do
+        for propertyKey, propertyValue in pairs(pair[2] or {}) do
+          instance[propertyKey] = propertyValue
+        end
+      end
+
+      setmetatable(instance, getmetatable(self))
+
+      if fields.constructor then
+        fields.constructor(instance, nil, ...)
+      else error('no constructor was provided') end
+
+      -- Constructor has finished, now validate
+      for propertyKey in pairs(promisedToBeConstructed) do
+        if instance[propertyKey] == nil then
+          error(('the `%s` was not instantiated in constructor as promised'):format(propertyKey))
+        end
+      end
+
+      return setmetatable({}, {
+        __index = function(_, propertyKey)
+          return get(instance, propertyKey)
+        end,
+        __newindex = function(_, propertyKey, varValue)
+          set(instance, propertyKey, varValue)
+        end
+      })
+    end
+  }, { })
+end
+
+local myClass<const> = class({
+  private = {
+    height = {nil, "number"},
+  },
+  get = {
+    blood = {nil, "string"},
+    getHeight = {function(self, new)
+      self.setHeight(self, new)
+      return self.height
+    end, "function"}
+  },
+  set = {
+    setHeight = {
+      function(new)
+        self.height = new
+      end, "function"
+    },
+  },
+  accessor = {
+    name = {nil, "string"},
+    age = {nil, "number"},
+  },
+  constructor = function(self, super, name, age, height, blood)
+    self.name = name
+    self.age = age
+    self.height = height
+    self.blood = blood
+  end
+})
+
+
+local Class<const> = myClass:new("Lenix", 20, 197, "O+")
+Class.setHeight = function(self, new)
+  self.height = new
+end
+
+
+
+print(Class.getHeight(198))
+
+
+
+
+