@amxts/core 0.1.0

package/scripts/docs/as/fs.ts

@@ -0,0 +1,173 @@
+// The tooltips of as/fs.ts, in both languages: scripts/apply-docs.ts writes the
+// one AMXTS_DOCS_LANG picks into the JSDoc above each element.
+export default {
+	'readFileSync': {
+		en: `
+			Reads a whole file as text; \`null\` when it cannot be opened.
+
+			\`\`\`ts
+			const text = fs.readFileSync("addons/amxmodx/configs/myplugin.ini");
+			if (text == null) return;
+			\`\`\`
+
+			The path is relative to the game folder (\`cstrike/\`), as for any AMX Mod X
+			plugin. The file is UTF-8; it is read whole, whatever its size.
+
+			Pawn: \`fopen\`, \`fread_blocks\`
+		`,
+		ru: `
+			Читает весь файл как текст; \`null\`, если его не удалось открыть.
+
+			\`\`\`ts
+			const text = fs.readFileSync("addons/amxmodx/configs/myplugin.ini");
+			if (text == null) return;
+			\`\`\`
+
+			Путь считается от папки игры (\`cstrike/\`), как у любого плагина AMX Mod X.
+			Файл в UTF-8; он читается целиком, какого бы размера ни был.
+
+			Pawn: \`fopen\`, \`fread_blocks\`
+		`,
+	},
+	'writeFileSync': {
+		en: `
+			Writes text to a file, replacing what was there; \`false\` when it cannot be
+			opened (a folder that does not exist, for one).
+
+			\`\`\`ts
+			fs.writeFileSync("addons/amxmodx/data/last-map.txt", server.map);
+			\`\`\`
+
+			Pawn: \`fopen\`, \`fputs\`
+		`,
+		ru: `
+			Записывает текст в файл вместо того, что там было; \`false\`, если файл не
+			удалось открыть (например, такой папки нет).
+
+			\`\`\`ts
+			fs.writeFileSync("addons/amxmodx/data/last-map.txt", server.map);
+			\`\`\`
+
+			Pawn: \`fopen\`, \`fputs\`
+		`,
+	},
+	'appendFileSync': {
+		en: `
+			Adds text to the end of a file, making it if there is none; \`false\` when it cannot be opened.
+
+			Pawn: \`fopen(path, "a")\`, \`fputs\`
+		`,
+		ru: `
+			Дописывает текст в конец файла, создавая его, если файла нет; \`false\`, если его не удалось открыть.
+
+			Pawn: \`fopen(path, "a")\`, \`fputs\`
+		`,
+	},
+	'existsSync': {
+		en: `
+			\`true\` when the file or folder exists.
+
+			Pawn: \`file_exists\`, \`dir_exists\`
+		`,
+		ru: `
+			\`true\`, если такой файл или папка есть.
+
+			Pawn: \`file_exists\`, \`dir_exists\`
+		`,
+	},
+	'readdirSync': {
+		en: `
+			Lists the names in a folder, without \`.\` and \`..\`; \`null\` when there is no
+			such folder.
+
+			\`\`\`ts
+			const maps = fs.readdirSync("maps");
+			\`\`\`
+
+			Pawn: \`open_dir\`, \`next_file\`
+		`,
+		ru: `
+			Возвращает имена в папке, без \`.\` и \`..\`; \`null\`, если такой папки нет.
+
+			\`\`\`ts
+			const maps = fs.readdirSync("maps");
+			\`\`\`
+
+			Pawn: \`open_dir\`, \`next_file\`
+		`,
+	},
+	'MakeDirectoryOptions': {
+		en: `The options of \`mkdirSync\`: \`{ recursive: true }\` makes the missing folders above too.`,
+		ru: `Настройки \`mkdirSync\`: \`{ recursive: true }\` создаёт и недостающие папки выше.`,
+	},
+	'MakeDirectoryOptions.recursive': {
+		en: `\`true\` to make every missing folder on the way too; \`false\` by default.`,
+		ru: `\`true\` — создать и все недостающие папки по пути; по умолчанию \`false\`.`,
+	},
+	'mkdirSync': {
+		en: `
+			Makes a folder; \`false\` when it cannot be made, or - without \`recursive\` -
+			when it is there already or its parent is not.
+
+			\`\`\`ts
+			fs.mkdirSync("addons/amxmodx/data/stats", { recursive: true });
+			\`\`\`
+
+			With \`{ recursive: true }\` every missing folder on the way is made, and a
+			folder that is already there is fine, as in Node.
+
+			Pawn: \`mkdir\`
+		`,
+		ru: `
+			Создаёт папку; \`false\`, если создать не удалось, или — без \`recursive\` —
+			если она уже есть или нет родительской.
+
+			\`\`\`ts
+			fs.mkdirSync("addons/amxmodx/data/stats", { recursive: true });
+			\`\`\`
+
+			С \`{ recursive: true }\` создаются все недостающие папки по пути, а уже
+			существующая папка — не ошибка, как в Node.
+
+			Pawn: \`mkdir\`
+		`,
+	},
+	'mkdir': {
+		en: `\`mkdirSync\` as a promise, rejected when the folder cannot be made.`,
+		ru: `\`mkdirSync\` в виде промиса; отклоняется, если папку не удалось создать.`,
+	},
+	'readFile': {
+		en: `
+			\`readFileSync\` as a promise: it rejects with an \`ENOENT\` error when the file
+			cannot be opened, like Node's \`fs.promises.readFile\`.
+
+			\`\`\`ts
+			const text = await fs.readFile("addons/amxmodx/configs/myplugin.ini");
+			\`\`\`
+		`,
+		ru: `
+			\`readFileSync\` в виде промиса: если файл не удалось открыть, отклоняется с
+			ошибкой \`ENOENT\`, как \`fs.promises.readFile\` в Node.
+
+			\`\`\`ts
+			const text = await fs.readFile("addons/amxmodx/configs/myplugin.ini");
+			\`\`\`
+		`,
+	},
+	'writeFile': {
+		en: `\`writeFileSync\` as a promise, rejected when the file cannot be opened.`,
+		ru: `\`writeFileSync\` в виде промиса; отклоняется, если файл не удалось открыть.`,
+	},
+	'appendFile': {
+		en: `\`appendFileSync\` as a promise, rejected when the file cannot be opened.`,
+		ru: `\`appendFileSync\` в виде промиса; отклоняется, если файл не удалось открыть.`,
+	},
+	'exists': {
+		en: `\`existsSync\` as a promise.`,
+		ru: `\`existsSync\` в виде промиса.`,
+	},
+	'readdir': {
+		en: `\`readdirSync\` as a promise, rejected when there is no such folder.`,
+		ru: `\`readdirSync\` в виде промиса; отклоняется, если такой папки нет.`,
+	},
+};

package/scripts/docs/as/lib/check.ts

@@ -0,0 +1,68 @@
+// The tooltips of as/lib/check.ts, in both languages: scripts/apply-docs.ts writes the
+// one AMXTS_DOCS_LANG picks into the JSDoc above each element.
+export default {
+	'Checks': {
+		en: `
+			Checks of one piece of the API on a live server. Each goes to the server
+			console with the tag, as \`[tag] ok ...\` or \`[tag] FAIL ...\`; the player
+			who ran them gets the total in chat.
+
+			\`\`\`ts
+			const check = new Checks("api-async", player);
+			check.expect(player.gravity, "gravity").toBeCloseTo(0.5);
+			check.done();
+			\`\`\`
+		`,
+		ru: `
+			Проверки одной части API на живом сервере. Каждая пишется в консоль
+			сервера с тегом — \`[tag] ok ...\` или \`[tag] FAIL ...\`; игрок, который
+			их запустил, получает итог в чат.
+
+			\`\`\`ts
+			const check = new Checks("api-async", player);
+			check.expect(player.gravity, "gravity").toBeCloseTo(0.5);
+			check.done();
+			\`\`\`
+		`,
+	},
+	'Checks.passed': {
+		en: `The number of checks passed so far.`,
+		ru: `Число пройденных проверок.`,
+	},
+	'Checks.failed': {
+		en: `The number of checks failed so far.`,
+		ru: `Число проваленных проверок.`,
+	},
+	'Checks.tag': {
+		en: `The checks' tag: every log line starts with it, \`[cvar]\`.`,
+		ru: `Тег проверок: с него начинается каждая строка лога, \`[cvar]\`.`,
+	},
+	'Checks.player': {
+		en: `The player who ran the checks, if any: the total is printed to him too.`,
+		ru: `Игрок, запустивший проверки, если их запустил игрок: итог выводится и ему.`,
+	},
+	'Checks.expect': {
+		en: `Starts a check of a value; \`what\` names it in the log: \`check.expect(player.gravity, "gravity")\`.`,
+		ru: `Начинает проверку значения; \`what\` — его имя в логе: \`check.expect(player.gravity, "gravity")\`.`,
+	},
+	'Checks.done': {
+		en: `Prints the total, to the log and to the player.`,
+		ru: `Выводит итог — в лог и игроку.`,
+	},
+	'Checks.record': {
+		en: `@hidden`,
+		ru: `@hidden Записывает одну проверку в лог и в итог.`,
+	},
+	'Expectation': {
+		en: `One value under check, from \`check.expect(...)\`: \`toBe\` or \`toBeCloseTo\` logs the result.`,
+		ru: `Одно проверяемое значение из \`check.expect(...)\`: \`toBe\` или \`toBeCloseTo\` пишут результат в лог.`,
+	},
+	'Expectation.toBe': {
+		en: `Checks the value equals \`expected\`: the same number, text or boolean.`,
+		ru: `Проверяет, что значение равно \`expected\`: то же число, текст или boolean.`,
+	},
+	'Expectation.toBeCloseTo': {
+		en: `Checks the number is within \`0.001\` of \`expected\`: a value the game stores comes back rounded (\`0.5\` as \`0.49999\`).`,
+		ru: `Проверяет, что число отличается от \`expected\` меньше чем на \`0.001\`: значение, которое хранит игра, возвращается округлённым (\`0.5\` как \`0.49999\`).`,
+	},
+};

package/scripts/docs/as/modules/http.ts

@@ -0,0 +1,66 @@
+// The tooltips of as/modules/http.ts, in both languages: scripts/apply-docs.ts writes the
+// one AMXTS_DOCS_LANG picks into the JSDoc above each element.
+export default {
+	'RequestInit': {
+		en: `A request's options besides its URL. Every field is optional.`,
+		ru: `Настройки запроса помимо URL. Все поля необязательны.`,
+	},
+	'RequestInit.method': {
+		en: `The request's method, one of \`"GET"\` (the default), \`"POST"\`, \`"PUT"\`, \`"PATCH"\`, \`"DELETE"\`.`,
+		ru: `Метод запроса, одно из \`"GET"\` (по умолчанию), \`"POST"\`, \`"PUT"\`, \`"PATCH"\`, \`"DELETE"\`.`,
+	},
+	'RequestInit.body': {
+		en: `The text sent with the request, such as JSON for a POST; empty by default.`,
+		ru: `Текст, который уходит с запросом, например JSON для POST; по умолчанию пустой.`,
+	},
+	'RequestInit.headers': {
+		en: `The request's headers, as pairs: \`[["Content-Type", "application/json"]]\`.`,
+		ru: `Заголовки запроса, парами: \`[["Content-Type", "application/json"]]\`.`,
+	},
+	'RequestInit.signal': {
+		en: `
+			A signal that cancels the request; the promise then rejects with an
+			Error named \`"AbortError"\`. In an async command handler or player event,
+			the player leaving cancels the request too.
+		`,
+		ru: `
+			Сигнал, который отменяет запрос; промис тогда отклоняется с Error с
+			именем \`"AbortError"\`. В async-обработчике команды или события игрока
+			запрос отменяется и тогда, когда игрок выходит.
+		`,
+	},
+	'Response': {
+		en: `The server's response to a request.`,
+		ru: `Ответ сервера на запрос.`,
+	},
+	'Response.status': {
+		en: `The response's HTTP status: \`200\`, \`404\`, ...`,
+		ru: `HTTP-статус ответа: \`200\`, \`404\`, ...`,
+	},
+	'Response.text': {
+		en: `The response's body, as text.`,
+		ru: `Тело ответа, текстом.`,
+	},
+	'Response.ok': {
+		en: `\`true\` for a 2xx status.`,
+		ru: `\`true\` при статусе 2xx.`,
+	},
+	'fetch': {
+		en: `
+			Sends a request. The promise is fulfilled with the response on a later
+			frame, and rejected when there is none - no connection, a bad URL, a
+			timeout, no \`easy_http\`, or an abort. An HTTP error such as \`404\` is a
+			response, as in fetch: check \`response.ok\`.
+
+			Pawn: \`ezhttp_get\`, \`ezhttp_post\` (easy_http)
+		`,
+		ru: `
+			Отправляет запрос. Промис выполняется с ответом в одном из следующих
+			кадров и отклоняется, если ответа нет: нет соединения, плохой URL,
+			таймаут, нет \`easy_http\` или отмена. HTTP-ошибка вроде \`404\` — это ответ,
+			как и в fetch: проверяйте \`response.ok\`.
+
+			Pawn: \`ezhttp_get\`, \`ezhttp_post\` (easy_http)
+		`,
+	},
+};

package/scripts/docs/as/os.ts

@@ -0,0 +1,16 @@
+// The tooltips of as/os.ts, in both languages: scripts/apply-docs.ts writes the
+// one AMXTS_DOCS_LANG picks into the JSDoc above each element.
+export default {
+	Platform: {
+		en: `The operating system's name as \`platform()\` gives it, with Node's names: one of \`"win32"\`, \`"linux"\`.`,
+		ru: `Имя операционной системы, как его даёт \`platform()\`, — те же имена, что в Node: одно из \`"win32"\`, \`"linux"\`.`,
+	},
+	platform: {
+		en: `Returns the operating system the server runs on, either \`"win32"\` or \`"linux"\`.`,
+		ru: `Возвращает операционную систему сервера, либо \`"win32"\`, либо \`"linux"\`.`,
+	},
+	EOL: {
+		en: `The line ending on this system, one of \`"\\r\\n"\` on Windows, \`"\\n"\` on Linux.`,
+		ru: `Конец строки в этой системе, одно из: \`"\\r\\n"\` на Windows, \`"\\n"\` на Linux.`,
+	},
+};

package/scripts/docs/as/promise.ts

@@ -0,0 +1,132 @@
+// The tooltips of as/promise.ts, in both languages: scripts/apply-docs.ts writes the
+// one AMXTS_DOCS_LANG picks into the JSDoc above each element.
+export default {
+	'PromiseBase': {
+		en: `The base of every Promise, whatever its value's type; a plugin uses Promise<T>.`,
+		ru: `Общая основа любого Promise, каким бы ни был тип значения; плагин пользуется Promise<T>.`,
+	},
+	'PromiseLike': {
+		en: `Anything with a \`then\`: the type \`await\` takes in the editor. In a plugin, \`await\` a Promise.`,
+		ru: `Всё, у чего есть \`then\`: тип, который \`await\` принимает в редакторе. В плагине \`await\` ждёт Promise.`,
+	},
+	'PromiseLike.then': {
+		en: `Calls \`onFulfilled\` with the value once there is one.`,
+		ru: `Вызывает \`onFulfilled\` со значением, когда оно появится.`,
+	},
+	'Promise': {
+		en: `A value that is not there yet: the result of a request, a timer, an async function.`,
+		ru: `Значение, которого ещё нет: результат запроса, таймера, async-функции.`,
+	},
+	'Promise.then': {
+		en: `
+			Calls \`onFulfilled\` with the value once there is one; the promise it
+			returns settles with what that returns. A rejection passes through to
+			it untouched, or to \`onRejected\` when there is one.
+		`,
+		ru: `
+			Вызывает \`onFulfilled\` со значением, когда оно появится; возвращённый
+			промис завершается тем, что вернёт \`onFulfilled\`. Отклонение переходит
+			в него как есть — или в \`onRejected\`, если он передан.
+		`,
+	},
+	'Promise.catch': {
+		en: `
+			Calls \`onRejected\` with the reason if this is rejected. What it returns
+			is the value instead: \`readFile(path).catch(() => "")\` - or nothing, when
+			it only logs.
+		`,
+		ru: `
+			Вызывает \`onRejected\` с причиной, если промис отклонён. То, что он
+			вернёт, становится значением взамен — \`readFile(path).catch(() => "")\`, —
+			или ничего, если он только пишет в лог.
+		`,
+	},
+	'Promise.finally': {
+		en: `Calls \`onFinally\` once this settles, either way, and passes the outcome on.`,
+		ru: `Вызывает \`onFinally\`, когда промис завершится, как бы ни завершился, и передаёт результат дальше.`,
+	},
+	'Promise.resolve': {
+		en: `A promise already fulfilled with \`value\`.`,
+		ru: `Промис, уже выполненный со значением \`value\`.`,
+	},
+	'Promise.reject': {
+		en: `A promise already rejected with \`reason\`.`,
+		ru: `Промис, уже отклонённый с причиной \`reason\`.`,
+	},
+	'PromiseSettledResult': {
+		en: `A promise's outcome, as Promise.allSettled gives it for each.`,
+		ru: `Итог промиса — то, что Promise.allSettled даёт для каждого.`,
+	},
+	'PromiseSettledResult.status': {
+		en: `The promise's outcome, either \`"fulfilled"\` or \`"rejected"\`.`,
+		ru: `Итог промиса, либо \`"fulfilled"\`, либо \`"rejected"\`.`,
+	},
+	'PromiseSettledResult.value': {
+		en: `The promise's value, when fulfilled.`,
+		ru: `Значение промиса, если он выполнен.`,
+	},
+	'PromiseSettledResult.reason': {
+		en: `The rejection's reason, when rejected.`,
+		ru: `Причина отказа, если промис отклонён.`,
+	},
+	'AggregateError': {
+		en: `The error Promise.any rejects with when every promise is rejected; their reasons are in \`errors\`.`,
+		ru: `Ошибка, с которой отклоняется Promise.any, когда отклонены все промисы; их причины лежат в \`errors\`.`,
+	},
+	'AggregateError.errors': {
+		en: `The reason each promise was rejected, in the order the promises were given.`,
+		ru: `Причины отказа каждого промиса, в том порядке, в каком промисы переданы.`,
+	},
+	'Event': {
+		en: `The event an abort listener gets.`,
+		ru: `Событие, которое получает обработчик отмены.`,
+	},
+	'Event.type': {
+		en: `The event's type; the only one here is \`"abort"\`.`,
+		ru: `Тип события; здесь он всегда \`"abort"\`.`,
+	},
+	'AbortSignal': {
+		en: `A signal to give something up: a request, a timer, everything a player started.`,
+		ru: `Сигнал бросить начатое: запрос, таймер, всё, что начал игрок.`,
+	},
+	'AbortSignal.aborted': {
+		en: `\`true\` once the signal has aborted.`,
+		ru: `\`true\`, если сигнал уже сработал.`,
+	},
+	'AbortSignal.reason': {
+		en: `The abort's reason: an Error named \`"AbortError"\` unless \`abort()\` was given one.`,
+		ru: `Причина отмены: Error с именем \`"AbortError"\`, если в \`abort()\` не передали свою.`,
+	},
+	'AbortSignal.addEventListener': {
+		en: `Calls \`listener\` when the signal aborts.`,
+		ru: `Вызывает \`listener\`, когда сигнал срабатывает.`,
+	},
+	'AbortSignal.removeEventListener': {
+		en: `Takes back a \`listener\` given to \`addEventListener\`: it is not called any more.`,
+		ru: `Убирает \`listener\`, переданный в \`addEventListener\`: он больше не вызывается.`,
+	},
+	'AbortSignal.timeout': {
+		en: `A signal that aborts by itself after \`ms\`, with an Error named \`"TimeoutError"\`.`,
+		ru: `Сигнал, который сам срабатывает через \`ms\` с Error с именем \`"TimeoutError"\`.`,
+	},
+	'AbortSignal.abort': {
+		en: `A signal that has aborted already.`,
+		ru: `Сигнал, который уже сработал.`,
+	},
+	'AbortSignal.any': {
+		en: `A signal that aborts when any of \`signals\` does.`,
+		ru: `Сигнал, который срабатывает, как только сработает любой из \`signals\`.`,
+	},
+	'AbortController': {
+		en: `A controller that aborts its \`signal\` on demand: \`controller.abort()\`.`,
+		ru: `Контроллер, который отменяет свой \`signal\` по команде: \`controller.abort()\`.`,
+	},
+	'AbortController.signal': {
+		en: `The controller's signal: hand it to fetch, sleep or anything else that takes one.`,
+		ru: `Сигнал контроллера: передайте его в fetch, sleep или куда угодно ещё, где принимают сигнал.`,
+	},
+	'AbortController.abort': {
+		en: `Aborts the signal, with \`reason\` or an Error named \`"AbortError"\`.`,
+		ru: `Отменяет сигнал с причиной \`reason\` или с Error с именем \`"AbortError"\`.`,
+	},
+};

package/scripts/docs/as/promise.types.ts

@@ -0,0 +1,63 @@
+// The tooltips of as/promise.types.d.ts, in both languages: scripts/apply-docs.ts writes the
+// one AMXTS_DOCS_LANG picks into the JSDoc above each element.
+export default {
+	'Awaited': {
+		en: `The value \`await\` gives of a promise or of a plain value - TypeScript's own name for it, which \`await 5\` and \`for await\` look up.`,
+		ru: `Значение, которое \`await\` даёт от промиса или обычного значения, — собственное имя TypeScript, которое ищут \`await 5\` и \`for await\`.`,
+	},
+	'Promise': {
+		en: `The statics that take a list of promises: \`all\`, \`allSettled\`, \`race\` and \`any\`.`,
+		ru: `Статические методы, которые принимают список промисов: \`all\`, \`allSettled\`, \`race\` и \`any\`.`,
+	},
+	'Promise.all': {
+		en: `
+			Waits for every promise and gives their values in order; rejects with the
+			first rejection. Promises of different types give a tuple:
+
+			\`\`\`ts
+			const [response, count] = await Promise.all([fetch(url), countAsync()]);
+			\`\`\`
+		`,
+		ru: `
+			Ждёт все промисы и отдаёт их значения по порядку; отклоняется с первой
+			же ошибкой. Промисы разных типов дают кортеж:
+
+			\`\`\`ts
+			const [response, count] = await Promise.all([fetch(url), countAsync()]);
+			\`\`\`
+		`,
+	},
+	'Promise.allSettled': {
+		en: `
+			Waits for every promise to settle, either way, and tells how each did:
+			\`status\` is \`"fulfilled"\` with \`value\`, or \`"rejected"\` with \`reason\`.
+		`,
+		ru: `
+			Ждёт, пока завершатся все промисы, как бы ни завершились, и сообщает,
+			как завершился каждый: \`status\` — \`"fulfilled"\` с \`value\` или
+			\`"rejected"\` с \`reason\`.
+		`,
+	},
+	'Promise.race': {
+		en: `
+			Settles like the first promise to settle. Promises of different types
+			need a common base class; a Promise<void> among them makes the value
+			nullable.
+		`,
+		ru: `
+			Завершается так же, как первый завершившийся промис. Промисам разных
+			типов нужен общий базовый класс; с Promise<void> среди них значение
+			может быть \`null\`.
+		`,
+	},
+	'Promise.any': {
+		en: `
+			Gives the first value to arrive; once all promises are rejected, rejects
+			with an AggregateError whose \`errors\` hold every reason.
+		`,
+		ru: `
+			Отдаёт первое полученное значение; если отклонены все промисы —
+			отклоняется с AggregateError, в \`errors\` которого все причины.
+		`,
+	},
+};

package/scripts/docs/as/vector.ts

@@ -0,0 +1,48 @@
+// The tooltips of as/vector.ts, in both languages: scripts/apply-docs.ts writes the
+// one AMXTS_DOCS_LANG picks into the JSDoc above each element.
+export default {
+	'Vector': {
+		en: `Three numbers, x y z, with the math a plugin needs on them.`,
+		ru: `Три числа, x y z, и вся математика над ними, которая нужна плагину.`,
+	},
+	'Vector.x': {
+		en: `The x coordinate, \`vector[0]\`.`,
+		ru: `Координата x, \`vector[0]\`.`,
+	},
+	'Vector.y': {
+		en: `The y coordinate, \`vector[1]\`.`,
+		ru: `Координата y, \`vector[1]\`.`,
+	},
+	'Vector.z': {
+		en: `The z coordinate, \`vector[2]\`.`,
+		ru: `Координата z, \`vector[2]\`.`,
+	},
+	'Vector.add': {
+		en: `A new vector: this one plus \`other\`, number by number.`,
+		ru: `Новый вектор: этот плюс \`other\`, число к числу.`,
+	},
+	'Vector.subtract': {
+		en: `A new vector: this one minus \`other\`, the way from \`other\` to this point.`,
+		ru: `Новый вектор: этот минус \`other\` — путь от \`other\` до этой точки.`,
+	},
+	'Vector.scale': {
+		en: `A new vector with every number multiplied by \`factor\`.`,
+		ru: `Новый вектор, где каждое число умножено на \`factor\`.`,
+	},
+	'Vector.dot': {
+		en: `The dot product with \`other\`; zero when the two are at right angles.`,
+		ru: `Скалярное произведение с \`other\`; ноль, если векторы перпендикулярны.`,
+	},
+	'Vector.magnitude': {
+		en: `The vector's length: the distance from the map's origin to this point.`,
+		ru: `Длина вектора: расстояние от начала координат карты до этой точки.`,
+	},
+	'Vector.distanceTo': {
+		en: `The distance from this point to \`other\`, in game units.`,
+		ru: `Расстояние от этой точки до \`other\`, в игровых единицах.`,
+	},
+	'Vector.normalize': {
+		en: `A new vector in the same direction, one unit long; a zero vector stays zero.`,
+		ru: `Новый вектор того же направления, длиной в единицу; нулевой вектор так и остаётся нулевым.`,
+	},
+};