@amxts/config-core 0.1.0

package/src/internal.ts

@@ -0,0 +1,44 @@
+/**
+ * Config Core's own bookkeeping. Not part of the API.
+ */
+import { ConfigFormat, ConfigKind } from "./types";
+
+/** A value of a config read as a tree: what a ConfigNode shows. */
+export interface TreeNode {
+	kind: ConfigKind;
+	/** The key it has in its object; "" in an array and at the top. */
+	key: string;
+	/** A scalar as it was written: a string's text, a number as written, "true", "false", "null" or "" for an empty value. */
+	text: string;
+	/** A number's value; 0 for anything else. */
+	value: number;
+	/** An object's members or an array's items, in order. */
+	items: TreeNode[];
+	/** The comment and blank lines read before it; null for none. */
+	comments: string[] | null;
+	/** Where it was read, from 1; 0 for one made at run time or a column not known. */
+	line: number;
+	column: number;
+	/** An object whose keys are found case-insensitively: an INI section's. */
+	foldCase: boolean;
+	/** A list that is an INI block of rows: written back as a block, even when each row is one value. */
+	block: boolean;
+}
+
+/** A config file read as a tree. */
+export interface TreeDocument {
+	/** The file's path; "" for a text that came from no file. */
+	file: string;
+	format: ConfigFormat;
+	root: TreeNode;
+	/** One level of indentation, as the file has it. */
+	indent: string;
+	/** The comment and blank lines after the last value. */
+	tail: string[] | null;
+}
+
+/** A place in a text: its line and column, from 1. */
+export interface Place {
+	line: number;
+	column: number;
+}

package/src/json.ts

@@ -0,0 +1,386 @@
+/**
+ * JSON for Config Core, with what JSONC adds: // and /* *\/ comments and a
+ * comma after the last member or item. Read into the tree and written back.
+ * Not part of the API.
+ */
+import { TreeDocument, TreeNode } from "./internal";
+import { BACKSLASH, isControl, isDigits, isHexDigits, isScalar, lineStarts, makeNode, numberNode, placeOf, unicodeEscape, writeComments } from "./tree";
+
+/** Escapes of JSON text: the letter after the backslash, and what it stands for, at the same place. */
+const ESCAPE_LETTERS = "\"\\/bfnrt";
+const ESCAPED = "\"\\/\u0008\u000C\u000A\u000D\u0009";
+
+function isWhitespace(character: string) {
+	return character == " " || character == "\t" || character == "\n";
+}
+
+/** A number as JSON writes one: -12, 3.5, 1e-3 - no +, no leading zeros, no bare dot. */
+function isJsonNumber(text: string) {
+	const body = text.startsWith("-") ? text.slice(1) : text;
+	let exponent = body.indexOf("e");
+	if (exponent < 0) exponent = body.indexOf("E");
+	let mantissa = body;
+
+	if (exponent >= 0) {
+		mantissa = body.slice(0, exponent);
+		const power = body.slice(exponent + 1);
+		if (!isDigits(power.startsWith("-") || power.startsWith("+") ? power.slice(1) : power)) return false;
+	}
+
+	const dot = mantissa.indexOf(".");
+	const whole = dot < 0 ? mantissa : mantissa.slice(0, dot);
+	if (!isDigits(whole) || (whole.length > 1 && whole.startsWith("0"))) return false;
+	return dot < 0 || isDigits(mantissa.slice(dot + 1));
+}
+
+/** Reads a JSON or JSONC text into the tree; the first thing it cannot read stops it, with the place. */
+export class JsonReader {
+	pos = 0;
+	/** What stopped the reading; "" while nothing has. */
+	error = "";
+	errorAt = 0;
+	/** One level of indentation as the text has it; "" until an indented line is met. */
+	indent = "";
+	/** Comment and blank lines waiting for the value they are written before. */
+	pending: string[] | null = null;
+	starts: number[];
+
+	constructor(public text: string) {
+		this.starts = lineStarts(text);
+	}
+
+	get failed() {
+		return this.error.length > 0;
+	}
+
+	fail(at: number, message: string) {
+		if (this.failed) return;
+		this.error = message;
+		this.errorAt = at;
+	}
+
+	placeAt(at: number) {
+		return placeOf(this.starts, at);
+	}
+
+	takeComments() {
+		const taken = this.pending;
+		this.pending = null;
+		return taken;
+	}
+
+	keep(line: string) {
+		let list = this.pending;
+
+		if (list == null) {
+			list = [];
+			this.pending = list;
+		}
+
+		list.push(line);
+	}
+
+	/**
+	 * Skips spaces and comments. A comment on a line of its own is kept for the
+	 * value after it, and so is a blank line; one after a value on its line is
+	 * dropped.
+	 */
+	skip() {
+		let lineEnds = 0;
+		let blankKept = false;
+
+		for (;;) {
+			const character = this.text.charAt(this.pos);
+
+			if (isWhitespace(character)) {
+				if (character == "\n") lineEnds++;
+				if (character == "\n" && lineEnds >= 2 && !blankKept) this.keep("");
+				if (character == "\n" && lineEnds >= 2) blankKept = true;
+				if (character == "\n" && this.indent.length == 0) this.noteIndent(this.pos + 1);
+				this.pos++;
+				continue;
+			}
+
+			if (character != "/") return;
+			const next = this.text.charAt(this.pos + 1);
+			const own = lineEnds > 0 || this.pos == 0;
+
+			if (next == "/") {
+				const end = this.text.indexOf("\n", this.pos);
+				const stop = end < 0 ? this.text.length : end;
+				if (own) this.keep(this.text.slice(this.pos, stop).trim());
+				this.pos = stop;
+			} else if (next == "*") {
+				const end = this.text.indexOf("*/", this.pos + 2);
+
+				if (end < 0) {
+					this.fail(this.pos, "a /* comment that is never closed with */");
+					return;
+				}
+
+				if (own) {
+					for (const line of this.text.slice(this.pos, end + 2).split("\n")) this.keep(line.trim());
+				}
+
+				this.pos = end + 2;
+			} else {
+				return;
+			}
+
+			lineEnds = 0;
+			blankKept = false;
+		}
+	}
+
+	noteIndent(start: number) {
+		let end = start;
+		while (this.text.charAt(end) == " " || this.text.charAt(end) == "\t") end++;
+		const next = this.text.charAt(end);
+		if (end > start && next != "\n" && next != "") this.indent = this.text.slice(start, end);
+	}
+
+	/** The document: one value, spaces and comments around it. */
+	read() {
+		this.skip();
+
+		if (this.pos >= this.text.length) {
+			const empty = makeNode("object", "", "", { line: 1, column: 1 });
+			empty.comments = this.takeComments();
+			return empty;
+		}
+
+		const comments = this.takeComments();
+		const root = this.value();
+		root.comments = comments;
+		this.skip();
+		if (this.pos < this.text.length) this.fail(this.pos, "unexpected text after the end of the value");
+		return root;
+	}
+
+	value() {
+		const at = this.pos;
+		const first = this.text.charAt(at);
+		if (first == "{") return this.object();
+		if (first == "[") return this.array();
+		if (first == "\"") return this.string();
+		let end = at;
+		while (end < this.text.length && !",]}/ \t\n".includes(this.text.charAt(end))) end++;
+		const word = this.text.slice(at, end);
+		const place = this.placeAt(at);
+		this.pos = end;
+		if (word == "true" || word == "false") return makeNode("boolean", "", word, place);
+		if (word == "null") return makeNode("null", "", word, place);
+		if (isJsonNumber(word)) return numberNode(word, parseFloat(word), place);
+		if (word.length == 0) this.fail(at, first.length > 0 ? `unexpected ${first}` : "the text ends where a value should be");
+		else if (first == "'") this.fail(at, "text is written in double quotes");
+		else this.fail(at, `"${word}" is not a value - text is written in double quotes`);
+		return makeNode("null", "", "", place);
+	}
+
+	object() {
+		const node = makeNode("object", "", "", this.placeAt(this.pos));
+		this.pos++;
+
+		while (!this.failed) {
+			this.skip();
+			if (this.failed) return node;
+
+			if (this.text.charAt(this.pos) == "}") {
+				this.pos++;
+				this.takeComments();
+				return node;
+			}
+
+			if (this.text.charAt(this.pos) != "\"") {
+				this.fail(this.pos, this.pos >= this.text.length ? "the object is never closed with }" : "a key is written in double quotes");
+				return node;
+			}
+
+			const comments = this.takeComments();
+			const keyAt = this.pos;
+			const key = this.string().text;
+			this.skip();
+
+			if (this.text.charAt(this.pos) != ":") {
+				this.fail(this.pos, "expected : after the key");
+				return node;
+			}
+
+			this.pos++;
+			this.skip();
+			this.takeComments();
+			const value = this.value();
+			if (this.failed) return node;
+			const twice = node.items.find(each => each.key == key);
+
+			if (twice != null) {
+				this.fail(keyAt, `"${key}" is here twice - first on line ${twice.line}`);
+				return node;
+			}
+
+			const place = this.placeAt(keyAt);
+			value.key = key;
+			value.line = place.line;
+			value.column = place.column;
+			value.comments = comments;
+			node.items.push(value);
+			if (!this.comma("}")) return node;
+		}
+		return node;
+	}
+
+	array() {
+		const node = makeNode("array", "", "", this.placeAt(this.pos));
+		this.pos++;
+
+		while (!this.failed) {
+			this.skip();
+			if (this.failed) return node;
+
+			if (this.text.charAt(this.pos) == "]") {
+				this.pos++;
+				this.takeComments();
+				return node;
+			}
+
+			if (this.pos >= this.text.length) {
+				this.fail(this.pos, "the array is never closed with ]");
+				return node;
+			}
+
+			const comments = this.takeComments();
+			const item = this.value();
+			if (this.failed) return node;
+			item.comments = comments;
+			node.items.push(item);
+			if (!this.comma("]")) return node;
+		}
+		return node;
+	}
+
+	/** After a member or an item: a comma, or the bracket that closes; false when it is neither. */
+	comma(close: string) {
+		this.skip();
+		const next = this.text.charAt(this.pos);
+
+		if (next == ",") {
+			this.pos++;
+			return true;
+		}
+
+		if (next != close) this.fail(this.pos, `expected , or ${close}`);
+		return next == close;
+	}
+
+	string() {
+		const at = this.pos;
+		let value = "";
+		let i = at + 1;
+
+		for (;;) {
+			const character = this.text.charAt(i);
+
+			if (character == "\"") {
+				i++;
+				break;
+			}
+
+			if (character == "" || character == "\n") {
+				this.fail(at, "text that is never closed with \"");
+				break;
+			}
+
+			if (character == BACKSLASH) {
+				const letter = this.text.charAt(i + 1);
+				const known = ESCAPE_LETTERS.indexOf(letter);
+				const hex = this.text.slice(i + 2, i + 6);
+
+				if (known >= 0 && letter.length == 1) {
+					value += ESCAPED.charAt(known);
+					i += 2;
+				} else if (letter == "u" && hex.length == 4 && isHexDigits(hex)) {
+					value += String.fromCharCode(parseInt(hex, 16));
+					i += 6;
+				} else {
+					this.fail(i, `an unknown escape ${BACKSLASH}${letter}`);
+					break;
+				}
+
+				continue;
+			}
+
+			value += character;
+			i++;
+		}
+
+		this.pos = i;
+		return makeNode("string", "", value, this.placeAt(at));
+	}
+}
+
+/** Text in double quotes, escaped as JSON escapes it. */
+export function jsonText(text: string) {
+	let quoted = "";
+	for (const character of text.split("")) {
+		if (character == "\"" || character == BACKSLASH) quoted += `${BACKSLASH}${character}`;
+		else if (character == "\n") quoted += `${BACKSLASH}n`;
+		else if (character == "\t") quoted += `${BACKSLASH}t`;
+		else if (isControl(character)) quoted += unicodeEscape(character);
+		else quoted += character;
+	}
+	return `"${quoted}"`;
+}
+
+function scalar(node: TreeNode) {
+	if (node.kind == "string") return jsonText(node.text);
+	if (node.kind == "number" && node.text.length > 0) return node.text;
+	// JSON has no NaN and no Infinity.
+	if (node.kind == "number") return isFinite(node.value) ? `${node.value}` : "null";
+	if (node.kind == "boolean") return node.text;
+	return "null";
+}
+
+/** An array of a few short scalars fits on one line: ["a", "b"]. */
+function oneLine(array: TreeNode) {
+	if (!array.items.every(item => (isScalar(item) || item.kind == "null") && item.comments == null)) return "";
+	const line = `[${array.items.map(scalar).join(", ")}]`;
+	return line.length <= 60 ? line : "";
+}
+
+/** A value's lines at `pad`: its first line goes after `head` (a key, or nothing), its last gets `end` (a comma, or nothing). */
+function writeValue(lines: string[], node: TreeNode, head: string, end: string, pad: string, unit: string) {
+	const container = node.kind == "object" || node.kind == "array";
+
+	if (!container || node.items.length == 0) {
+		const empty = node.kind == "object" ? "{}" : "[]";
+		lines.push(`${pad}${head}${container ? empty : scalar(node)}${end}`);
+		return;
+	}
+
+	const short = node.kind == "array" ? oneLine(node) : "";
+
+	if (short.length > 0) {
+		lines.push(`${pad}${head}${short}${end}`);
+		return;
+	}
+
+	lines.push(`${pad}${head}${node.kind == "object" ? "{" : "["}`);
+	const inner = pad + unit;
+	for (let i = 0; i < node.items.length; i++) {
+		const each = node.items[i];
+		writeComments(lines, each.comments, inner);
+		const key = node.kind == "object" ? `${jsonText(each.key)}: ` : "";
+		writeValue(lines, each, key, i < node.items.length - 1 ? "," : "", inner, unit);
+	}
+	lines.push(`${pad}${node.kind == "object" ? "}" : "]"}${end}`);
+}
+
+/** The document as JSON lines, its comments kept. */
+export function writeJson(document: TreeDocument) {
+	const lines: string[] = [];
+	const unit = document.indent.length > 0 ? document.indent : "  ";
+	writeComments(lines, document.root.comments, "");
+	writeValue(lines, document.root, "", "", "", unit);
+	writeComments(lines, document.tail, "");
+	return lines;
+}

package/src/natives.ts

@@ -0,0 +1,271 @@
+/**
+ * Config Core for Pawn plugins: the 28 cfg_* natives of the original
+ * universal_config.amxx, as include/universal_config.inc declares them.
+ */
+import { Player, plugin, print, server } from "~/facade";
+import { console_print } from "~/natives";
+import { setBaseDir } from "./index";
+import * as ini from "./ini";
+
+plugin({ name: "Config Core", version: "0.1.0", author: "kukson777", description: "INI configs for plugins: the cfg_* natives", include: "universal_config.inc" });
+
+/** A loaded config file. */
+export enum ConfigFile {
+	CFG_FILE_INVALID = -1,
+}
+
+/** A section of a loaded file. */
+export enum ConfigSection {
+	CFG_SECTION_INVALID = -1,
+}
+
+/** What a key is: a `key = value` line or a `key = { ... }` block. */
+export enum EntryType {
+	CFG_ENTRY_SIMPLE,
+	CFG_ENTRY_BRACKET,
+}
+
+/** What a key holds: one value, a line of strings, or rows - one value is a line of one string. */
+export enum ContentType {
+	CFG_CONTENT_SIMPLE,
+	CFG_CONTENT_STRINGS,
+	CFG_CONTENT_ENTRIES,
+}
+
+server.addEventListener("init", () => {
+	console.log("[ConfigCore] Plugin initialized (v0.1.0)");
+});
+
+server.addCommand("dump_config", dumpConfig, { access: "Cvar", description: "Dumps all configurations" });
+
+/** Every loaded section and its entries: headings to the admin's console, entries to the server's, as the original does. */
+function dumpConfig(player: Player) {
+	print(player, "Current Configuration Dump:", "console");
+	for (const section of ini.dump()) {
+		print(player, section.heading, "console");
+		for (const line of section.lines) console_print(0, line);
+	}
+}
+
+/**
+ * Loads a config file from `configs/<base dir>/`; ".ini" is added when the
+ * name has none. A file that is not there still gets a handle, empty.
+ */
+export function cfg_load_file(fileName: string) {
+	return ini.configHandle(ini.loadFile(fileName));
+}
+
+/** A section of a loaded file by its name, or CFG_SECTION_INVALID. */
+export function cfg_get_section(cfg: ConfigFile, sectionName: string) {
+	const config = ini.configByHandle(cfg);
+	const found = config != null ? ini.section(config, sectionName) : null;
+	return found != null ? ini.sectionHandle(found) : -1;
+}
+
+/**
+ * The value of a key, or of a path ("block/subkey"), into value[]; index is
+ * the value's place in its line. false when there is none.
+ */
+export function cfg_get_value(section: ConfigSection, key: string, index = 0) {
+	const found = ini.sectionByHandle(section);
+	return found != null ? ini.getValue(found, key, index) : null;
+}
+
+/** A value by a path: index is its place in the line, lineIndex the row of the block. */
+export function cfg_get_value_by_path(section: ConfigSection, path: string, index = 0, lineIndex = 0) {
+	const found = ini.sectionByHandle(section);
+	return found != null ? ini.getValueByPath(found, path, index, lineIndex) : null;
+}
+
+/** The whole number a key or path holds; 0 when there is none. */
+export function cfg_get_int(section: ConfigSection, key: string, index = 0) {
+	const found = ini.sectionByHandle(section);
+	return found != null ? ini.getInt(found, key, index) : 0;
+}
+
+/** The number a key or path holds; 0.0 when there is none. */
+export function cfg_get_float(section: ConfigSection, key: string, index = 0) {
+	const found = ini.sectionByHandle(section);
+	return found != null ? ini.getNumber(found, key, index) : 0;
+}
+
+/** true when the value is a whole number other than 0. */
+export function cfg_get_bool(section: ConfigSection, key: string, index = 0) {
+	const found = ini.sectionByHandle(section);
+	return found != null ? ini.getBoolean(found, key, index) : false;
+}
+
+/**
+ * The words of a key's line (index: which line, when the key is there more
+ * than once); for a block, every value of every row. The caller destroys the
+ * array; Invalid_Array when there are no words.
+ */
+export function cfg_get_value_array(section: ConfigSection, key: string, index = 0) {
+	const found = ini.sectionByHandle(section);
+	if (found == null) return null;
+	return ini.getWords(found, key, index);
+}
+
+/** The numbers of value index as an array of Floats; the caller destroys it. Invalid_Array when there are none. */
+export function cfg_get_float_array(section: ConfigSection, key: string, index = 0) {
+	const found = ini.sectionByHandle(section);
+	if (found == null) return null;
+	const numbers = ini.getNumbers(found, key, index);
+	return numbers != null && numbers.length > 0 ? numbers : null;
+}
+
+/**
+ * Every value of the line a path leads to (lineIndex: the row of a block), as
+ * written. The caller destroys the array.
+ */
+export function cfg_get_value_array_by_path(section: ConfigSection, path: string, index = 0, lineIndex = 0) {
+	const found = ini.sectionByHandle(section);
+	if (found == null) return null;
+	return ini.getValues(found, path, index, lineIndex);
+}
+
+/** The section's keys in file order; Invalid_Array when it has none. */
+export function cfg_get_top_level_keys(section: ConfigSection) {
+	const found = ini.sectionByHandle(section);
+	if (found == null) return null;
+	const keys = ini.keys(found);
+	return keys.length > 0 ? keys : null;
+}
+
+/**
+ * The whole section, as an array of three: the keys, the values (an array of
+ * strings per key, "{block}" for a block) and [key, value] index pairs.
+ */
+export function cfg_get_section_data(section: ConfigSection) {
+	const found = ini.sectionByHandle(section);
+	if (found == null) return null;
+	const entries = ini.entries(found);
+	if (entries.length == 0) return null;
+
+	const pairs: number[][] = [];
+	for (let i = 0; i < entries.length; i++) pairs.push([i, i]);
+	const data: SectionData = {
+		keys: entries.map(entry => entry.key),
+		values: entries.map(entry => (entry.block ? ["{block}"] : entry.values)),
+		pairs,
+	};
+	return data;
+}
+
+/** What cfg_get_section_data hands Pawn: an Array of these three, in this order. */
+interface SectionData {
+	keys: string[];
+	values: string[][];
+	/** [key, value] index pairs. */
+	pairs: number[][];
+}
+
+/** How many values a line has, rows a block has, or - for a key that is there more than once - how many times it is. */
+export function cfg_get_array_size(section: ConfigSection, key: string) {
+	const found = ini.sectionByHandle(section);
+	return found != null ? ini.size(found, key) : 0;
+}
+
+/** Sets a value; a key that is not there is made. For a block, lineIndex is the row. */
+export function cfg_set_value(section: ConfigSection, key: string, value: string, index = 0, lineIndex = 0) {
+	const found = ini.sectionByHandle(section);
+	return found != null ? ini.set(found, key, value, index, lineIndex) : false;
+}
+
+/** Sets a whole number. */
+export function cfg_set_int(section: ConfigSection, key: string, value: number, index = 0) {
+	const found = ini.sectionByHandle(section);
+	return found != null ? ini.setInt(found, key, value, index) : false;
+}
+
+/** Sets a number; it is written as it was given, 2.5 as "2.5". */
+export function cfg_set_float(section: ConfigSection, key: string, value: number, index = 0) {
+	const found = ini.sectionByHandle(section);
+	return found != null ? ini.setNumber(found, key, value, index) : false;
+}
+
+/** Sets 1 or 0. */
+export function cfg_set_bool(section: ConfigSection, key: string, value: boolean, index = 0) {
+	const found = ini.sectionByHandle(section);
+	return found != null ? ini.setBoolean(found, key, value, index) : false;
+}
+
+/** Removes every entry of the key; false when there was none. */
+export function cfg_delete_key(section: ConfigSection, key: string) {
+	const found = ini.sectionByHandle(section);
+	return found != null ? ini.remove(found, key) : false;
+}
+
+/** Whether the section has the key. */
+export function cfg_has_key(section: ConfigSection, key: string) {
+	const found = ini.sectionByHandle(section);
+	return found != null ? ini.has(found, key) : false;
+}
+
+/** A section of the file; one that is not there is made, in memory. */
+export function cfg_create_section(cfg: ConfigFile, sectionName: string) {
+	const config = ini.configByHandle(cfg);
+	return config != null ? ini.sectionHandle(ini.createSection(config, sectionName)) : -1;
+}
+
+/** Makes the key a line of values or a block; a key that is not there is made. */
+export function cfg_set_entry_type(section: ConfigSection, key: string, entryType: EntryType) {
+	const kind = entryType == EntryType.CFG_ENTRY_BRACKET ? "block" : "value";
+	const found = ini.sectionByHandle(section);
+	if (found == null) return false;
+	ini.setKind(found, key, kind);
+	return true;
+}
+
+/** Says what the key holds; a key that is not there is made. */
+export function cfg_set_entry_content_type(section: ConfigSection, key: string, contentType: ContentType) {
+	const content = contentType == ContentType.CFG_CONTENT_ENTRIES ? "entries" : "strings";
+	const found = ini.sectionByHandle(section);
+	if (found == null) return false;
+	ini.setContent(found, key, content);
+	return true;
+}
+
+/**
+ * Writes one section to a file; the file's other sections are not in it.
+ * With cfg = CFG_FILE_INVALID the section is looked for in every loaded file.
+ */
+export function cfg_write_file(cfg: ConfigFile, fileName: string, sectionName: string) {
+	const config = ini.configByHandle(cfg);
+	// No file named: the section of that name in any file, the last one loaded.
+	const found = config != null ? ini.section(config, sectionName) : ini.findSection(sectionName);
+	return found != null && ini.writeSection(found, fileName);
+}
+
+/**
+ * Saves every section of the file with the comments it was read with. The
+ * file name has to be given: without one it returns false.
+ */
+export function cfg_save_config(cfg: ConfigFile, fileName?: string) {
+	const config = ini.configByHandle(cfg);
+	return config != null && ini.saveFile(config, fileName ?? "");
+}
+
+/** The folder under configs/ that file names are relative to. */
+export function cfg_set_base_dir(dir: string) {
+	setBaseDir(dir);
+}
+
+/** How many sections are loaded, across every file. */
+export function cfg_get_sections_count() {
+	return ini.sectionCount();
+}
+
+/** A section's name by its number, 0 .. cfg_get_sections_count() - 1. */
+export function cfg_get_section_name(index: number) {
+	return ini.sectionByHandle(index)?.name ?? null;
+}
+
+/**
+ * The comment line written above row `row` of the block `key` - "; ID | VALUE",
+ * say; "" removes it. false when there is no such block or row.
+ */
+export function cfg_set_row_comment(section: ConfigSection, key: string, row: number, comment: string) {
+	const found = ini.sectionByHandle(section);
+	return found != null ? ini.setRowComment(found, key, row, comment) : false;
+}