remove mkdocs specific syntax

docs/containers/kubernetes.md

@@ -110,7 +110,7 @@ Each kubernetes configuration file is composed by 3 parts:
 
 ### `kubectl get`
 
-```sh linenums="1"
+```sh
 kubectl config get-contexts  # list available contexts
 
 kubectl get namespaces  # list namespaces inside current context
@@ -121,12 +121,12 @@ kubectl get pod [-n|--namespace <namespace>] <pod> -o|--output jsonpath='{.spec.
 
 ### `kubectl exec`
 
-```sh linenums="1"
+```sh
 kubectl exec [-i|--stdin] [-t|--tty] [-n|--namespace <namespace>] <pod> [-c|--container <container>] -- <command>  # execute a command inside a container
 ```
 
 ### `kubectl logs`
 
-```sh linenums="1"
+```sh
 kubectl logs [-f|--follow] [-n|--namespace <namespace>] <pod> [-c|--container]  # get pod/container logs
 ```

docs/databases/mongo-db.md

@@ -25,7 +25,7 @@ MongoDB automatically creates an `ObjectId()` if it's not provided.
 To create a database is sufficient to switch towards a non existing one with `use <database>` (implicit creation).
 The database is not actually created until a document is inserted.
 
-```sh linenums="1"
+```sh
 show dbs  # list all databases
 use <database>  # use a particular database
 show collections  # list all collection for the current database
@@ -38,7 +38,7 @@ db.<collection>.insertOne({document})  # implicit collection creation
 
 ## Operators (MQL Syntax)
 
-```json linenums="1"
+```json
 /* --- Update operators --- */
 { "$inc":  { "<key>": "<increment>", ... } }  // increment value
 { "$set":  { "<key>": "<value>", ... } }  // set value
@@ -83,7 +83,7 @@ db.<collection>.insertOne({document})  # implicit collection creation
 
 > **Note**:  `$<key>` is used to access the value of the field dynamically
 
-```json linenums="1"
+```json
 { "$expr": { "<expression>" } }  // aggregation expression, variables, conditional expressions
 { "$expr":  { "$<comparison_operator>": [ "$<key>", "$<key>" ] } }  // compare field values (operators use aggregation syntax)
 ```
@@ -99,7 +99,7 @@ Insertion results:
 - error -> rollback
 - success -> entire documents gets saved
 
-```sh linenums="1"
+```sh
 # explicit collection creation, all options are optional
 db.createCollection( <name>,
    {
@@ -132,7 +132,7 @@ db.<collection>.insertMany([ { document }, { document } ] , { "ordered": false }
 
 ### Querying
 
-```sh linenums="1"
+```sh
 db.<collection>.findOne()  # find only one document
 db.<collection>.find(filter)  # show selected documents
 db.<collection>.find().pretty()  # show documents formatted
@@ -176,7 +176,7 @@ db.<collection>.find().hint( { $natural : -1 } )  # force the query to perform a
 
 [Update Operators](https://docs.mongodb.com/manual/reference/operator/update/ "Update Operators Documentation")
 
-```sh linenums="1"
+```sh
 db.<collection>.replaceOne(filter, update, options)
 db.<collection>.updateOne(filter, update, {upsert: true})  # modify document if existing, insert otherwise
 
@@ -185,7 +185,7 @@ db.<collection>.updateOne(filter, { "$push": { ... }, "$set": { ... }, { "$inc":
 
 ### Deletion
 
-```sh linenums="1"
+```sh
 db.<collection>.deleteOne(filter, options)
 db.<collection>.deleteMany(filter, options)
 
@@ -203,7 +203,7 @@ Utility to import all docs into a specified collection.
 If the collection already exists `--drop` deletes it before reuploading it.
 **WARNING**: CSV separators must be commas (`,`)
 
-```sh linenums="1"
+```sh
 mongoimport <options> <connection-string> <file>
 
 --uri=<connectionString>
@@ -222,7 +222,7 @@ mongoimport <options> <connection-string> <file>
 
 Utility to export documents into a specified file.
 
-```sh linenums="1"
+```sh
 mongoexport --collection=<collection> <options> <connection-string>
 
 --uri=<connectionString>
@@ -276,7 +276,7 @@ Indexes _slow down writing operations_ since the index must be updated at every
 
 ### Diagnosis and query planning
 
-```sh linenums="1"
+```sh
 db.<collection>.find({...}).explain()  # explain won't accept other functions
 db.explain().<collection>.find({...})  # can accept other functions
 db.explain("executionStats").<collection>.find({...})  # more info
@@ -284,7 +284,7 @@ db.explain("executionStats").<collection>.find({...})  # more info
 
 ### Index Creation
 
-```sh linenums="1"
+```sh
 db.<collection>.createIndex( <key and index type specification>, <options> )
 
 db.<collection>.createIndex( { "<key>": <type>, "<key>": <type>, ... } )  # normal, compound or multikey (field is array) index
@@ -306,7 +306,7 @@ db.<collection>.createIndex(
 
 ### [Index Management](https://docs.mongodb.com/manual/tutorial/manage-indexes/)
 
-```sh linenums="1"
+```sh
 # view all db indexes
 db.getCollectionNames().forEach(function(collection) {
    indexes = db[collection].getIndexes();
@@ -343,7 +343,7 @@ handling connections, requests and persisting the data.
 
 ### Basic Shell Helpers
 
-```sh linenums="1"
+```sh
 db.<method>()  # database interaction
 db.<collection>.<method>()  # collection interaction
 rs.<method>();  # replica set deployment and management
@@ -382,7 +382,7 @@ Log Verbosity Level:
 - `0`: Default Verbosity (Information)
 - `1 - 5`: Increases the verbosity up to Debug messages
 
-```sh linenums="1"
+```sh
 db.getLogComponents()  # get components and their verbosity
 db.adminCommand({"getLog": "<scope>"})  # retrieve logs (getLog must be run on admin db -> adminCommand)
 db.setLogLevel(<level>, "<component>");  # set log level (output is OLD verbosity levels)
@@ -408,7 +408,7 @@ Events captured by the profiler:
 
 > **Note**: Logs are saved in the `system.profile` _capped_ collection.
 
-```sh linenums="1"
+```sh
 db.setProfilingLevel(n)  # set profiler level
 db.setProfilingLevel(1, { slowms: <ms> })
 db.getProfilingStatus()  # check profiler status
@@ -456,7 +456,7 @@ Built-in Roles Groups and Names:
 - Backup/Restore: `backup`, `restore`
 - Super User: `root`
 
-```sh linenums="1"
+```sh
 db.createUser({
     user: "<username>",
     pwd: "<password>",
@@ -538,7 +538,7 @@ Variable syntax in aggregations:
 
 Filters the documents to pass only the documents that match the specified condition(s) to the next pipeline stage.
 
-```sh linenums="1"
+```sh
 db.<collection>.aggregate([ 
     { "$match": { "<query>" } },
 
@@ -570,7 +570,7 @@ Passes along the documents with the requested fields to the next stage in the pi
 - [`$sum`][$sum_docs]
 - [`$avg`][$avg_docs]
 
-```sh linenums="1"
+```sh
 db.<collection>.aggregate([ 
      { 
         "$project": { 
@@ -627,7 +627,7 @@ db.<collection>.aggregate([
 Adds new fields to documents (can be result of computation).  
 `$addFields` outputs documents that contain _all existing fields_ from the input documents and newly added fields.
 
-```sh linenums="1"
+```sh
 db.<collection>.aggregate({
     { $addFields: { <newField>: <expression>, ... } }
 })
@@ -639,7 +639,7 @@ db.<collection>.aggregate({
 
 The $`group` stage separates documents into groups according to a "group key". The output is one document for each unique group key.
 
-```sh linenums="1"
+```sh
 db.<collection>.aggregate([ 
      { 
         "$group": {
@@ -658,7 +658,7 @@ db.<collection>.aggregate([
 Deconstructs an array field from the input documents to output a document for each element.  
 Each output document is the input document with the value of the array field replaced by the element
 
-```sh linenums="1"
+```sh
 db.<collection>.aggregate([ 
      { "$unwind": "<array-key>" }
 
@@ -676,7 +676,7 @@ db.<collection>.aggregate([
 
 ### [`$count` Aggregation Stage][$count_docs]
 
-```sh linenums="1"
+```sh
 db.<collection>.aggregate([ 
      { "$count": "<count-key>" }
 ])
@@ -686,7 +686,7 @@ db.<collection>.aggregate([
 
 ### [`$sort` Aggregation Stage][$sort_docs]
 
-```sh linenums="1"
+```sh
 db.<collection>.aggregate([ 
      { 
         "$sort": { 
@@ -705,7 +705,7 @@ db.<collection>.aggregate([
 
 ### [`$skip` Aggregation Stage][$skip_docs]
 
-```sh linenums="1"
+```sh
 db.<collection>.aggregate([ 
      { "$skip": "<positive 64-bit integer>" }
 ])
@@ -715,7 +715,7 @@ db.<collection>.aggregate([
 
 ### [`$limit` Aggregation Stage][$limit_docs]
 
-```sh linenums="1"
+```sh
 db.<collection>.aggregate([ 
      { "$limit": "<positive 64-bit integer>" }
 ])
@@ -730,7 +730,7 @@ The `$lookup` stage adds a new array field to each input document. The new array
 
 > **Note**: To combine elements from two different collections, use the [`$unionWith`][$unionWith_docs] pipeline stage.
 
-```sh linenums="1"
+```sh
 db.<collection>.aggregate([ 
     {
         "$lookup": {
@@ -753,7 +753,7 @@ Performs a recursive search on a collection, with options for restricting the se
 
 The collection on which the aggregation is performed and the `from` collection can be the same (in-collection search) or different (cross-collection search)
 
-```sh linenums="1"
+```sh
 db.<collection>.aggregate([
     {
         $graphLookup: {
@@ -783,7 +783,7 @@ Each output document contains two fields: an `_id` field containing the distinct
 
 The documents are sorted by count in descending order.
 
-```sh linenums="1"
+```sh
 db.<collection>.aggregate([
     { $sortByCount:  <expression> }
 ])

docs/databases/redis.md

@@ -10,14 +10,14 @@ Often Redis it is called a *data structure* server because it has outer key-valu
 
 ### Server Startup
 
-```bash linenums="1"
+```bash
 redis-server  # start the server
 redis-cli
 ```
 
 ### [Key-Value Pairs](https://redis.io/commands#generic)
 
-```sh linenums="1"
+```sh
 SET <key> <value> [ EX <seconds> ] # store a key-value pair, TTL optional
 GET <key>  # read a key content
 EXISTS <key>  # check if a key exists
@@ -40,7 +40,7 @@ PERSIST <key>  # make the key permanent
 
 A list is a series of ordered values.
 
-```sh linenums="1"
+```sh
 RPUSH <key> <value1> <value2> ... # add one or more values to the end of the list
 LPUSH <key> <value1> <value2> ...  # add one or more values to the start of a list
 
@@ -55,7 +55,7 @@ RPOP  # remove and return the last item fro the list
 
 A set is similar to a list, except it does not have a specific order and each element may only appear once.
 
-```sh linenums="1"
+```sh
 SADD <key> <value1> <value2> ... # add one or more values to the set (return 0 if values are already inside)
 SREM <key> <value>  # remove the given member from the set, return 1 or 0 to signal if the member was actually there or not.
 SPOP <key> <value>  # remove and return value from the set
@@ -72,7 +72,7 @@ Sets are a very handy data type, but as they are unsorted they don't work well f
 
 A sorted set is similar to a regular set, but now each value has an associated score. This score is used to sort the elements in the set.
 
-```sh linenums="1"
+```sh
 ZADD <key> <score> <value>  # add a value with it's score
 
 ZRANGE <key> <start_index> <end_index>  # return a subset of the sortedSet
@@ -84,7 +84,7 @@ ZRANGE <key> <start_index> <end_index>  # return a subset of the sortedSet
 
 Hashes are maps between string fields and string values, so they are the perfect data type to represent objects.
 
-```sh linenums="1"
+```sh
 HSET <key> <field> <value> [ <field> <value> ... ] # set the string of a hash field
 HSETNX <key> <field> <value>  # set the value of a hash field, only if the field does not exist
 

docs/databases/sql.md

@@ -2,7 +2,7 @@
 
 ## DDL
 
-```sql linenums="1"
+```sql
 show databases;    -- mostra database
 CREATE DATABASE <database>;    -- database creation
 use <database_name>;    -- usa un database particolare
@@ -16,7 +16,7 @@ show tables;    -- mostra tabelle del database
 
 ### Table Creation
 
-```sql linenums="1"
+```sql
 CREATE TABLE <table_name>
     (<field_name> <field_type> <option>,
     ...);
@@ -24,7 +24,7 @@ CREATE TABLE <table_name>
 
 ### PRIMARY KEY from multiple fields
 
-```sql linenums="1"
+```sql
 CREATE TABLE <table_name>(
     ...,
     PRIMARY KEY (<field1>, ...),
@@ -33,7 +33,7 @@ CREATE TABLE <table_name>(
 
 ### Table Field Options
 
-```sql linenums="1"
+```sql
 PRIMARY KEY -- marks primary key as field option
 NOT NULL -- marks a necessary field
 REFERENCES <table> (<field>) -- adds foreign key reference
@@ -43,7 +43,7 @@ UNIQUE (<field>) -- set field as unique (MySQL)
 
 ### Table Modification
 
-```sql linenums="1"
+```sql
 ALTER TABLE <table>
     ADD PRIMARY KEY (<field>, ...),    -- definition of PK after table creation
     ADD <field_name> <field_type> <option>;    -- addition of a new field, field will have no value in the table
@@ -63,20 +63,20 @@ ALTER TABLE <table>
 
 ### Data Insertion
 
-```sql linenums="1"
+```sql
 INSERT INTO <table> (field_1, ...) VALUES (value_1, ...), (value_1, ...);
 INSERT INTO <table> VALUES (value_1, ...), (value_1, ...);    -- field order MUST respect tables's columns order
 ```
 
 ### Data Update
 
-```sql linenums="1"
+```sql
 UPDATE <table> SET <field> = <value>, <field> = <value>, ... WHERE <condition>;
 ```
 
 ### Data Elimination
 
-```sql linenums="1"
+```sql
 DELETE FROM <table> WHERE <condition>
 DELETE FROM <table> -- empty the table
 ```
@@ -85,7 +85,7 @@ DELETE FROM <table> -- empty the table
 
 `*`: denotes all table fields
 
-```sql linenums="1"
+```sql
 SELECT * FROM <table>;    -- show table contents
 SHOW columns FROM <table>;    -- show table columns
 DESCRIBE <table>;    -- shows table
@@ -93,13 +93,13 @@ DESCRIBE <table>;    -- shows table
 
 ### Alias
 
-```sql linenums="1"
+```sql
 SELECT <field> as <alias>; -- shows <field/funzione> with name <alias>
 ```
 
 ### Conditional Selection
 
-```sql linenums="1"
+```sql
 SELECT * FROM <table> WHERE <condition>;    -- shows elements that satisfy the condition
 AND, OR, NOT    -- logic connectors
 
@@ -108,7 +108,7 @@ SELECT * FROM <table> WHERE <field> Between <value_1> AND <value_2>;
 
 ### Ordering
 
-```sql linenums="1"
+```sql
 SELECT * FROM <table> ORDER BY <field>, ...;    -- shows the table ordered by <field>
 SELECT * FROM <table> ORDER BY <field>, ... DESC;    -- shows the table ordered by <field>, decreasing order
 SELECT * FROM <table> ORDER BY <field>, ... LIMIT n;    -- shows the table ordered by <field>, shows n items
@@ -117,7 +117,7 @@ SELECT TOP(n) * FROM <table> ORDER BY <field>, ...;    -- T-SQL
 
 ## Grouping
 
-```sql linenums="1"
+```sql
 SELECT * FROM <table> GROUP BY <field>;
 SELECT * FROM <table> GROUP BY <field> HAVING <condition>;
 SELECT DISTINCT <field> FROM <table>;    -- shows elements without repetitions
@@ -127,7 +127,7 @@ SELECT DISTINCT <field> FROM <table>;    -- shows elements without repetitions
 
 `%`: any number of characters
 
-```sql linenums="1"
+```sql
 SELECT * FROM <table> WHERE <field> LIKE '<char>%';    -- selects items in <field> that start with <char>
 SELECT * FROM <table> WHERE <field> LIKE '%<char>';    -- selects items in <field> that end with <char>
 SELECT * FROM <table> WHERE <field> LIKE '%<char>%';    -- selects items in <field> that contain <char>
@@ -136,14 +136,14 @@ SELECT * FROM <table> WHERE <field> NOT LIKE '%<char>%';    -- selects items in
 
 ### Selection from multiple tables
 
-```sql linenums="1"
+```sql
 SELECT a.<field>, b.<field> FROM <table> AS a, <table> AS b
     WHERE a.<field> ...;
 ```
 
 ## Functions
 
-```sql linenums="1"
+```sql
 SELECT COUNT(*) FROM <field>;    -- count of items in <field>
 SELECT MIN(*) FROM <table>;    -- min value
 SELECT MAX(*) FROM <table>;    -- max value
@@ -154,7 +154,7 @@ ANY (SELECT ...)
 
 ## Nested Queries
 
-```sql linenums="1"
+```sql
 SELECT * FROM <table> WHERE EXISTS (SELECT * FROM <table>)  -- selected field existing in subquery
 SELECT * FROM <table> WHERE NOT EXISTS (SELECT * FROM <table>)  -- selected field not existing in subquery
 ```
@@ -163,7 +163,7 @@ SELECT * FROM <table> WHERE NOT EXISTS (SELECT * FROM <table>)  -- selected fiel
 
 Create new table with necessary fields:
 
-```sql linenums="1"
+```sql
 CREATE TABLE <table> (
     (<field_name> <field_type> <option>,
     ...);
@@ -172,14 +172,14 @@ CREATE TABLE <table> (
 
 Fill fields with data from table:
 
-```sql linenums="1"
+```sql
 INSERT INTO <table>
     SELECT <fields> FROM <TABLE> WHERE <condition>;
 ```
 
 ## Join
 
-```sql linenums="1"
+```sql
 SELECT * FROM <table1> JOIN <table2> ON <table1>.<field> = <table2>.<field>;
 SELECT * FROM <table1> LEFT JOIN <table2> ON <condition>;
 SELECT * FROM <table1> RIGHT JOIN <table2> ON <condition>
@@ -189,7 +189,7 @@ SELECT * FROM <table1> RIGHT JOIN <table2> ON <condition>
 
 ## Multiple Join
 
-```sql linenums="1"
+```sql
 SELECT * FROM <table1>
 JOIN <table2> ON <table1>.<field> = <table2>.<field>
 JOIN <table3> ON <table2>.<field> = <table3>.<field>;
@@ -203,7 +203,7 @@ JOIN <table3> ON <table2>.<field> = <table3>.<field>;
 
 ### T-SQL Insert From table
 
-```sql linenums="1"
+```sql
 USE [<db_name>]
 
 SET IDENTITY_INSERT [<destination_table>] ON
@@ -217,7 +217,7 @@ SET IDENTITY_INSERT [<destination_table>] OFF
 
 ### T-SQL Parametric Query
 
-```sql linenums="1"
+```sql
 -- variable declaration
 DECLARE @var_name <type>
 
@@ -238,7 +238,7 @@ GO
 
 A view represents a virtual table. Join multiple tables in a view and use the view to present the data as if the data were coming from a single table.
 
-```sql linenums="1"
+```sql
 CREATE VIEW <name> AS
 SELECT * FROM <table> ...
 ```
@@ -250,7 +250,7 @@ SELECT * FROM <table> ...
 
 Stored Procedure Definition:
 
-```sql linenums="1"
+```sql
 CREATE PROCEDURE <Procedure_Name>
     -- Add the parameters for the stored procedure here
     <@Param1> <Datatype_For_Param1> = <Default_Value_For_Param1>,
@@ -268,7 +268,7 @@ GO
 
 Stored Procedure call in query:
 
-```sql linenums="1"
+```sql
 USE <database>
 GO
 

docs/languages/bash/commands.md

@@ -8,7 +8,7 @@
 
 [sudo vs su](https://unix.stackexchange.com/questions/35338/su-vs-sudo-s-vs-sudo-i-vs-sudo-bash/35342)
 
-```bash linenums="1"
+```bash
 sudo su  # login as root (user must be sudoers, root password not required) DANGEROUS
 sudo -s  # act as root and inherit current user environment (env as is now, along current dir and env vars) SAFE (can modify user environment)
 sudo -i  # act as root and and use a clean environment (goes to user's home, runs .bashrc) SAFEST
@@ -22,7 +22,7 @@ su USER  # change user but don't load it's home folder
 
 ### Getting Info
 
-```sh linenums="1"
+```sh
 man COMMAND  # show command manual
 help COMMAND  # show command info
 whatis COMMAND  # one-line command explanation
@@ -35,7 +35,7 @@ id  # Print user and group information for the specified USER, or (when USER omi
 
 ### Moving & Showing Directory Contents
 
-```sh linenums="1"
+```sh
 pwd  # print working (current) directory
 ls [option]... [FILE]...   # list directory contents ("list storage")
 cd rel_path  # change directory to path (rel_path must be inside current directory)
@@ -49,7 +49,7 @@ popd  # return to previous directory (before pushd)
 
 ### Creating, Reading, Copying, Moving, Modifying Files And Directories
 
-```sh linenums="1"
+```sh
 touch FILE  # change FILE timestamp fi exists, create file otherwise
 cat [FILE]  # concatenate files and print on standard output (FD 1)
 cat >> FILE  # append following content ot file (Ctrl+D to stop)
@@ -84,7 +84,7 @@ cp SOURCE DESTINATION  # copy SOURCE to DESTINATION
 
 ![Linux Permissions](../../img/bash_files-permissions-and-ownership-basics-in-linux.png "files info and permissions")
 
-```sh linenums="1"
+```sh
 chmod MODE FILE  # change file (or directory) permissions
 chmod OCTAL-MODE FILE  # change file (or directory) permissions
 
@@ -121,7 +121,7 @@ chgrp [OPTION]... GROUP FILE...  # change group ownership
 
 ### Finding Files And Directories
 
-```sh linenums="1"
+```sh
 find [path] [expression]   # search file in directory hierarchy
 find [start-position] -type f -name FILENAME  # search for a file named "filename"
 find [start-position] -type d -name DIRNAME  # search for a directory named "dirname"
@@ -134,7 +134,7 @@ find [path] -exec <command> {} \;  # execute command on found items (identified
 
 ### Other
 
-```sh linenums="1"
+```sh
 tee  # copy standard input and write to standard output AND files simultaneously
 tee [FILE]
 command | sudo tee FILE  # operate on file w/o using shell as su
@@ -171,7 +171,7 @@ watch -n SECONDS COMMAND  # execute command every SECONDS seconds (no less than
 
 **Data wrangling** is the process of transforming and mapping data from one "raw" data form into another format with the intent of making it more appropriate and valuable for a variety of downstream purposes such as analytics.
 
-```bash linenums="1"
+```bash
 sed  # stream editor for filtering and transforming text
 sed -E "s/REGEX/replacement/"  # substitute text ONCE (-E uses modern REGEX)
 sed -E "s/REGEX/replacement/g"  # substitute text multiple times (every match)

docs/languages/bash/scripting.md

@@ -44,20 +44,20 @@ shebang indicating which interpreter to use
 
 ### Simple Command
 
-```bash linenums="1"
+```bash
 [ var=value ... ] command [ arg ... ] [ redirection ... ]  # [.] is optional component
 ```
 
 ### Pipelines (commands concatenation)
 
-```bash linenums="1"
+```bash
 command | file.ext  # link the first process' standard output to the second process' standard input
 command |& file.ext  # link the first process' standard output & standard error to the second process' standard input
 ```
 
 ### Lists (sequence of commands)
 
-```bash linenums="1"
+```bash
 command_1; command_2; ...  # execute command in sequence, one after the other
 command_1 || command_2 || ...  # execute successive commands only if preceding ones fail
 command_1 && command_2 && ..  # execute successive commands only if preceding ones succeeds
@@ -65,7 +65,7 @@ command_1 && command_2 && ..  # execute successive commands only if preceding on
 
 ### COMPOUND COMMANDs (multiple commands as one)
 
-```bash linenums="1"
+```bash
 # block of commands executed as one
 <keyword>
     command_1; command_2; ...
@@ -108,7 +108,7 @@ We can copy file descriptors to make them share a stream. There are also many ot
 
 ### Redirections
 
-```bash linenums="1"
+```bash
 [x]>file  # make FD x write to file
 [x]<file  # make FD x read from file
 
@@ -142,7 +142,7 @@ x>&-, x<&-  # close FD x (stream disconnected from FD x)
 
 With Command Substitution, we effectively write a command within a command, and we ask bash to expand the inner command into its output and use that output as argument data for the main command.  
 
-```bash linenums="1"
+```bash
 $(inner_command)  # $ --> value-expansion prefix
 command !*  # !* expands to everything except the first argument in the previous line
 command !$  # refers to the last argument of the previous command
@@ -151,7 +151,7 @@ sudo !! # !! expands to the entire previous command
 
 ## Shell Variables
 
-```bash linenums="1"
+```bash
 varname=value  # variable assignment
 varname="$(command)"  # command substitution, MUST be double-quoted
 "$varname", "${varname}"  # variable expansion, MUST be double-quoted (name substituted w/ variable content)
@@ -188,7 +188,7 @@ Omit the pattern to match any character.
 
 Only the final exit code after executing the entire list is relevant for the branch's evaluation.
 
-```bash linenums="1"
+```bash
 if command_list; then
     command_list;
 elif command_list; then
@@ -207,7 +207,7 @@ fi
 
 ### Comparison Operators
 
-```bash linenums="1"
+```bash
 [[ "$a" -eq "$b" ]]  # is equal to
 [[ "$a" -ne "$b" ]]  # in not equal to
 [[ "$a" -gt "$b" ]]  # greater than
@@ -218,7 +218,7 @@ fi
 
 ### Arithmetic Comparison Operators
 
-```bash linenums="1"
+```bash
 (("$a" > "$b"))  # greater than
 (("$a" >= "$b"))   # greater than or equal to
 (("$a" < "$b"))  # less than
@@ -227,7 +227,7 @@ fi
 
 ### String Comparison Operators
 
-```bash linenums="1"
+```bash
 [ "$a" = "$b" ]    # is equal to (whitespace around operator)
 
 [[ $a == z* ]]     # True if $a starts with an "z" (pattern matching)
@@ -246,14 +246,14 @@ fi
 
 ## Commands short circuit evaluation
 
-```bash linenums="1"
+```bash
 command_1 || command_2  # if command_1 fails executes command_2
 command_1 && command_2  # executes command_2 only if command_1 succeeds
 ```
 
 ## Loops
 
-```bash linenums="1"
+```bash
 for var in iterable ; do
     # command here
 done
@@ -261,7 +261,7 @@ done
 
 ## Script Hardening
 
-```sh linenums="1"
+```sh
 set -o errexit  # exit on error
 set -o nounset  # fail on unset variable (bypass with ${VAR:-})
 set -o pipefail  # file entire pipeline if one step fails

docs/languages/c/c.md

@@ -2,7 +2,7 @@
 
 ## Library Import
 
-```c linenums="1"
+```c
 #include <stdio.h>  // search in current + system directories
 #include "lib.h" // search in current directory
 ```
@@ -22,7 +22,7 @@ Can be omitted and replaced by namespace`::`
 
 ## Main Function
 
-```c linenums="1"
+```c
 int main(int argc, char *argv[]) { }
 ```
 
@@ -30,14 +30,14 @@ int main(int argc, char *argv[]) { }
 
 ### Constant Declaration
 
-```c linenums="1"
+```c
 #define constant_name value
 const type constant_name = value;
 ```
 
 ### Variable Declaration
 
-```c linenums="1"
+```c
 type var_name = value;    //c-like initialization
 type var_name (value);    //constructor initialization
 type var_name {value};    //uniform initialization
@@ -124,7 +124,7 @@ Escape Character   | Character
 
 ### Standard Output
 
-```c linenums="1"
+```c
 #include <stdio.h>
 
 printf_s("text %<fmt_spec>", variable);
@@ -132,7 +132,7 @@ printf_s("text %<fmt_spec>", variable);
 
 ### Standard Input
 
-```c linenums="1"
+```c
 #include <stdio.h>
 
 scanf_s("%<fmt_spec>", &variable);    //return number of successfully accepted inputs
@@ -236,7 +236,7 @@ a `>>=` b   | a = a >> b
 
 ### Mathematical Functions
 
-```c linenums="1"
+```c
 #include <cmath>
 
 abs(x);    // absolute value
@@ -263,7 +263,7 @@ tanh(x);    //hyperbolic tan(X)
 
 ### Character Functions
 
-```c linenums="1"
+```c
 isalnum(c);    //true if c is alphanumeric
 isalpha(c);    //true if c is a letter
 isdigit(c);    //true if char is 0 1 2 3 4 5 6 7 8 9
@@ -283,7 +283,7 @@ toupper(c);    //transform character in uppercase
 
 ### String Functions
 
-```c linenums="1"
+```c
 strlen(string);    //return length (num of chars) of the string
 strcat(destination, source);    //appends chars of string2 to string1
 strncat(string1, string2, nchar);    //appends the first n chars of string 2 to string1
@@ -301,7 +301,7 @@ strpbrk(string, charSet);    //Returns a pointer to the first occurrence of any
 
 ### String Conversion
 
-```c linenums="1"
+```c
 atof(string);    //converts string in double if possible
 atoi(string);    //converts string in integer if possible
 atol(string);    //converts string in long if possible
@@ -309,7 +309,7 @@ atol(string);    //converts string in long if possible
 
 ### String Methods
 
-```C linenums="1"++
+```C++
 string.at(pos);    // returns char at index pos
 string.substr(start, end);    // returns substring between indexes START and END
 string.c_str();    //reads string char by char
@@ -318,7 +318,7 @@ string.find(substring);    // The zero-based index of the first character in str
 
 ## Vectors
 
-```c linenums="1"
+```c
 #include <vector>
 vector<type> vector_name = {values};    //variable length array
 ```
@@ -327,7 +327,7 @@ vector<type> vector_name = {values};    //variable length array
 
 ### If Statements
 
-```c linenums="1"
+```c
 if (condition) { }
 
 if (condition) 
@@ -346,7 +346,7 @@ else
 
 ### Switch
 
-```c linenums="1"
+```c
 switch (expression) {
     case constant_1:
         //code here
@@ -365,7 +365,7 @@ switch (expression) {
 
 ### While Loop
 
-```c linenums="1"
+```c
 while (condition) {
     //code here
 }
@@ -373,7 +373,7 @@ while (condition) {
 
 ### Do While
 
-```c linenums="1"
+```c
 do {
     //code here
 } while (condition);
@@ -381,7 +381,7 @@ do {
 
 ### For Loop
 
-```c linenums="1"
+```c
 for (initialization; condition; increase) {
     //code here
 }
@@ -401,7 +401,7 @@ Functions **must** be declared **before** the main function.
 It is possible to declare functions **after** the main only if the *prototype* is declared **before** the main.  
 To return multiple variables those variables can be passed by reference so that their values is adjourned in the main.
 
-```c linenums="1"
+```c
 type function_name(type argument1, ...); // function prototype
 
 type functionName (parameters) {
@@ -416,7 +416,7 @@ void functionName (parameters) { }
 Passing arguments by reference causes modifications made inside the function to be propagated to the values outside.  
 Passing arguments by values copies the values to the arguments: changes remain inside the function.  
 
-```c linenums="1"
+```c
 type functionName (type &argument1, ...) {
     //code here
     return <expression>;
@@ -430,7 +430,7 @@ type functionName (type &argument1, ...) {
 Passing arguments by reference causes modifications made inside the function to be propagated to the values outside.  
 Passing arguments by values copies the values to the arguments: changes remain inside the function.
 
-```c linenums="1"
+```c
 type function_name (type *argument_1, ...) {
     instructions;
     return <expression>;
@@ -441,7 +441,7 @@ type function_name (type *argument_1, ...) {
 
 ## Arrays
 
-```c linenums="1"
+```c
 type arrayName[dimension];    //array declaration
 type arrayName[dimension] = {value1, value2, ...};    //array declaration & initialization, values number must match dimension
 
@@ -454,7 +454,7 @@ array[index] = value;    //value assignment at position index
 The dimension is not specified because it is determined by the passed array.  
 The array is passed by reference.
 
-```c linenums="1"
+```c
 type function(type array[]){
     //code here
 }
@@ -469,14 +469,14 @@ function(array);    //array passed w/out square brackets []
 
 ### Multi-Dimensional Array (Matrix)
 
-```c linenums="1"
+```c
 type matrix[rows][columns];
 matrix[i][j]    //element A_ij of the matrix
 ```
 
 ### Matrix as function parameter
 
-```c linenums="1"
+```c
 //matrix passed by reference, second dimension is mandatory
 type function(type matrix[][columns]){
     //code here
@@ -496,7 +496,7 @@ type function(type matrix[][dim2]...[dimN]){
 
 ### Struct Definition
 
-```c linenums="1"
+```c
 struct Struct {
     type field1;
     type field2;
@@ -512,7 +512,7 @@ variable.field    // field access
 
 Pointers hold memory addresses of declared variables, they should be initialized to NULL.
 
-```c linenums="1"
+```c
 type *pointer = &variable;     //pointer init and assignment
 type *pointer = NULL;
 type *pointer = otherPointer;
@@ -523,7 +523,7 @@ type **pointerToPointer = &pointer;    // pointerToPointer -> pointer -> variabl
 pointer type and variable type **must** match.  
 (*) --> "value pointed to by"
 
-```c linenums="1"
+```c
 pointer    //address of pointed value (value of variable)
 *pointer    //value of pointed variable
 **pointer //value pointed by *pointer (pointer to pointer)
@@ -531,7 +531,7 @@ pointer    //address of pointed value (value of variable)
 
 ### Pointer to array
 
-```c linenums="1"
+```c
 type *pointer;
 type array[dim] = {};
 
@@ -542,7 +542,7 @@ pointer++;    //change pointed value to successive "cell" of array
 
 ### Pointers, Arrays & Functions
 
-```c linenums="1"
+```c
 func(array)    //pass entire array to function (no need to use (&) to extract address)
 
 type func(type* array){
@@ -552,7 +552,7 @@ type func(type* array){
 
 ### Pointer to Struct
 
-```c linenums="1"
+```c
 (*structPointer).field    //access to field value
 structPointer->structField    //access to field value
 ```
@@ -576,7 +576,7 @@ Every node is composed by two parts:
 A **Stack** is a list in with nodes can be extracted from one *side* only (*LIFO*).
 The extraction of an item from the *top* is called **pop**
 
-```c linenums="1"
+```c
 // node structure
 struct Node {
     type value;
@@ -586,7 +586,7 @@ struct Node {
 
 #### Node Insertion
 
-```c linenums="1"
+```c
 Node *stackNode;    //current node
 Node* head = NULL;    //pointer to head of stack
 
@@ -603,7 +603,7 @@ head = stackNode;    //update head to point to new first node
 
 #### Node Deletion
 
-```c linenums="1"
+```c
 stackNode = head->next;    //memorize location of second node
 free(head);    //delete first node
 head = stackNode;    //update head to point to new first node
@@ -611,7 +611,7 @@ head = stackNode;    //update head to point to new first node
 
 #### Passing Head To Functions
 
-```c linenums="1"
+```c
 type function(Node** head)    //value of head passed by address (head is Node*)
 {
     *head = ...    //update value of head (pointed variable/object/Node)
@@ -644,7 +644,7 @@ C does not automatically free allocated memory when nodes are deleted. It must b
 * `malloc()` returns a void pointer if the allocation is successful.
 * `free()` frees the memory
 
-```C linenums="1"
+```C
 list *pointer = (list*)malloc(sizeof(list));    //memory allocation
 free(pointer)    //freeing of memory
 ```
@@ -666,7 +666,7 @@ The available classes in C++ to operate on files are:
 
 Filename can be string literal or CharArray (use `c_str()`).
 
-```c linenums="1"
+```c
 ifstream file;
 file.open("filename");    //read from file
 

docs/languages/dotnet/asp.net/blazor.md

@@ -18,7 +18,7 @@ The component class is usually written in the form of a Razor markup page with a
 
 [Blazor Components](https://docs.microsoft.com/en-us/aspnet/core/blazor/components/)
 
-```cs linenums="1"
+```cs
 @page "/route/{RouteParameter}"  // make component accessible from a URL
 @page "/route/{RouteParameter?}"  // specify route parameter as optional
 @page "/route/{RouteParameter:<type>}"  // specify route parameter type
@@ -59,7 +59,7 @@ The component class is usually written in the form of a Razor markup page with a
 
 It's now possible to pass state when navigating in Blazor apps using the `NavigationManager`.
 
-```cs linenums="1"
+```cs
 navigationManager.NavigateTo("/<route>", new NavigationOptions { HistoryEntryState = value });
 ```
 
@@ -67,12 +67,12 @@ This mechanism allows for simple communication between different pages. The spec
 
 ### Blazor WASM
 
-```cs linenums="1"
+```cs
 // setup state singleton
 builder.Services.AddSingleton<StateContainer>();
 ```
 
-```cs linenums="1"
+```cs
 // StateContainer singleton
 using System;
 
@@ -96,7 +96,7 @@ public class StateContainer
 }
 ```
 
-```cs linenums="1"
+```cs
 // component that changes the state
 @inject StateContainer State
 
@@ -113,7 +113,7 @@ public class StateContainer
 }
 ```
 
-```cs linenums="1"
+```cs
 // component that should be update on state change
 @implements IDisposable
 @inject StateContainer State
@@ -139,7 +139,7 @@ public class StateContainer
 
 ## Data Binding & Events
 
-```cs linenums="1"
+```cs
 <p>
     <button @on{DOM EVENT}="{DELEGATE}" />
     <button @on{DOM EVENT}="{DELEGATE}" @on{DOM EVENT}:preventDefault />  // prevent default action
@@ -198,7 +198,7 @@ public class StateContainer
 
 To render a Blazor component from JavaScript, first register it as a root component for JavaScript rendering and assign it an identifier:
 
-```cs linenums="1"
+```cs
 // Blazor Server
 builder.Services.AddServerSideBlazor(options =>
 {
@@ -211,7 +211,7 @@ builder.RootComponents.RegisterForJavaScript<Counter>(identifier: "counter");
 
 Load Blazor into the JavaScript app (`blazor.server.js` or `blazor.webassembly.js`) and then render the component from JavaScript into a container element using the registered identifier, passing component parameters as needed:
 
-```js linenums="1"
+```js
 let containerElement = document.getElementById('my-counter');
 await Blazor.rootComponents.add(containerElement, 'counter', { incrementAmount: 10 });
 ```
@@ -223,6 +223,6 @@ Custom elements use standard HTML interfaces to implement custom HTML elements.
 
 To create a custom element using Blazor, register a Blazor root component as custom elements like this:
 
-```cs linenums="1"
+```cs
 options.RootComponents.RegisterAsCustomElement<Counter>("my-counter");
 ```

docs/languages/dotnet/asp.net/middleware.md

@@ -33,7 +33,7 @@ Short-circuiting is often desirable because it avoids unnecessary work.
 
 It's possible to perform actions both *before* and *after* the next delegate:
 
-```cs linenums="1"
+```cs
 // "inline" middleware, best if in own class
 app.Use(async (context, next) =>
 {
@@ -45,7 +45,7 @@ app.Use(async (context, next) =>
 
 `Run` delegates don't receive a next parameter. The first `Run` delegate is always terminal and terminates the pipeline.
 
-```cs linenums="1"
+```cs
 // "inline" middleware, best if in own class
 app.Use(async (context, next) =>
 {
@@ -69,7 +69,7 @@ The Endpoint middleware executes the filter pipeline for the corresponding app t
 
 The order that middleware components are added in the `Startup.Configure` method defines the order in which the middleware components are invoked on requests and the reverse order for the response. The order is **critical** for security, performance, and functionality.
 
-```cs linenums="1"
+```cs
 if (env.IsDevelopment())
 {
     app.UseDeveloperExceptionPage();
@@ -121,7 +121,7 @@ Unlike with `MapWhen`, this branch is rejoined to the main pipeline if it doesn'
 
 Middleware is generally encapsulated in a class and exposed with an extension method.
 
-```cs linenums="1"
+```cs
 public class CustomMiddleware
 {
     private readonly RequestDelegate _next;
@@ -152,7 +152,7 @@ The middleware class **must** include:
 
 ## Middleware Extension Methods
 
-```cs linenums="1"
+```cs
 using Microsoft.AspNetCore.Builder;
 
 public static class MiddlewareExtensions
@@ -164,7 +164,7 @@ public static class MiddlewareExtensions
 }
 ```
 
-```cs linenums="1"
+```cs
 // other middlewares
 
 app.UseCustom();  // add custom middleware in the pipeline

docs/languages/dotnet/asp.net/minimal-api.md

@@ -2,7 +2,7 @@
 
 > **Note**: Requires .NET 6+
 
-```cs linenums="1"
+```cs
 var builder = WebApplication.CreateBuilder(args);
 
 builder.Services.AddSingleton<IService, Service>();
@@ -41,7 +41,7 @@ Setting a value is done with `dotnet user-secrets set <key> <value>`, keys can b
 
 ## Swagger
 
-```cs linenums="1"
+```cs
 builder.Services.AddEndpointsApiExplorer();
 builder.Services.AddSwaggerGen();
 
@@ -59,7 +59,7 @@ app.MapPost("/route", Handler).Accepts<Type>(contentType);
 
 ## MVC
 
-```cs linenums="1"
+```cs
 builder.Services.AddControllersWithViews();
 //or
 builder.Services.AddControllers();
@@ -95,7 +95,7 @@ app.MapControllerRoute(
 
 To define routes and handlers using Minimal APIs, use the `Map(Get|Post|Put|Delete)` methods.
 
-```cs linenums="1"
+```cs
 // the dependencies are passed as parameters in the handler delegate
 app.MapGet("/route/{id}", (IService service, int id) => {
     
@@ -112,7 +112,7 @@ IResult Search(int id, int? page = 1, int? pageSize = 10) { /* ... */ }
 The `MapGroup()` extension method, which helps organize groups of endpoints with a common prefix.  
 It allows for customizing entire groups of endpoints with a singe call to methods like `RequireAuthorization()` and `WithMetadata()`.
 
-```cs linenums="1"
+```cs
 var group = app.MapGroup("<route-prefix>");
 
 group.MapGet("/", GetAllTodos);  // route: /<route-prefix>
@@ -126,14 +126,14 @@ group.MapGet("/{id}", GetTodo);  // route: /<route-prefix>/{id}
 The `Microsoft.AspNetCore.Http.TypedResults` static class is the “typed” equivalent of the existing `Microsoft.AspNetCore.Http.Results` class.  
 It's possible to use `TypedResults` in minimal APIs to create instances of the in-framework `IResult`-implementing types and preserve the concrete type information.
 
-```cs linenums="1"
+```cs
 public static async Task<IResult> GetAllTodos(TodoDb db)
 {
     return TypedResults.Ok(await db.Todos.ToArrayAsync());
 }
 ```
 
-```cs linenums="1"
+```cs
 [Fact]
 public async Task GetAllTodos_ReturnsOkOfObjectResult()
 {
@@ -152,7 +152,7 @@ public async Task GetAllTodos_ReturnsOkOfObjectResult()
 
 The `Results<TResult1, TResult2, TResultN>` generic union types, along with the `TypesResults` class, can be used to declare that a route handler returns multiple `IResult`-implementing concrete types.
 
-```cs linenums="1"
+```cs
 // Declare that the lambda returns multiple IResult types
 app.MapGet("/todos/{id}", async Results<Ok<Todo>, NotFound> (int id, TodoDb db)
 {
@@ -164,7 +164,7 @@ app.MapGet("/todos/{id}", async Results<Ok<Todo>, NotFound> (int id, TodoDb db)
 
 ## Filters
 
-```cs linenums="1"
+```cs
 public class ExampleFilter : IRouteHandlerFilter
 {
     public async ValueTask<object?> InvokeAsync(RouteHandlerInvocationContext context, RouteHandlerFilterDelegate next)
@@ -177,7 +177,7 @@ public class ExampleFilter : IRouteHandlerFilter
 }
 ```
 
-```cs linenums="1"
+```cs
 app.MapPost("/route", Handler).AddFilter<ExampleFilter>();
 ```
 
@@ -191,7 +191,7 @@ With Minimal APIs it's possible to access the contextual information by passing
 - `ClaimsPrincipal`
 - `CancellationToken` (RequestAborted)
 
-```cs linenums="1"
+```cs
 app.MapGet("/hello", (ClaimsPrincipal user) => {
     return "Hello " + user.FindFirstValue("sub");
 });
@@ -201,7 +201,7 @@ app.MapGet("/hello", (ClaimsPrincipal user) => {
 
 The `Microsoft.AspNetCore.OpenApi` package exposes a `WithOpenApi` extension method that generates an `OpenApiOperation` derived from a given endpoint’s route handler and metadata.
 
-```cs linenums="1"
+```cs
 app.MapGet("/todos/{id}", (int id) => ...)
     .WithOpenApi();
 
@@ -217,7 +217,7 @@ app.MapGet("/todos/{id}", (int id) => ...)
 Using [Minimal Validation](https://github.com/DamianEdwards/MinimalValidation) by Damian Edwards.  
 Alternatively it's possible to use [Fluent Validation](https://fluentvalidation.net/).
 
-```cs linenums="1"
+```cs
 app.MapPost("/widgets", (Widget widget) => {
     var isValid = MinimalValidation.TryValidate(widget, out var errors);
 
@@ -240,7 +240,7 @@ class Widget
 
 ## JSON Serialization
 
-```cs linenums="1"
+```cs
 // Microsoft.AspNetCore.Http.Json.JsonOptions
 builder.Services.Configure<JsonOptions>(opt =>
 {
@@ -250,7 +250,7 @@ builder.Services.Configure<JsonOptions>(opt =>
 
 ## Authorization
 
-```cs linenums="1"
+```cs
 builder.Services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme).AddJwtBearer();
 
 builder.Services.AddAuthorization();
@@ -283,13 +283,13 @@ app.MapGet("/special-secret", () => "This is a special secret!")
 The `user-jwts` tool is similar in concept to the existing `user-secrets` tools, in that it can be used to manage values for the app that are only valid for the current user (the developer) on the current machine.  
 In fact, the `user-jwts` tool utilizes the `user-secrets` infrastructure to manage the key that the JWTs will be signed with, ensuring it’s stored safely in the user profile.
 
-```sh linenums="1"
+```sh
 dotnet user-jwts create  # configure a dev JWT fot the current user
 ```
 
 ## Output Caching
 
-```cs linenums="1"
+```cs
 builder.Services.AddOutputCaching();  // no special options
 builder.Services.AddOutputCaching(options => 
 {
@@ -321,7 +321,7 @@ app.MapGet("/<route>", [OutputCache(/* options */)]RouteHandler);
 
 ### Cache Eviction
 
-```cs linenums="1"
+```cs
 
 app.MapGet("/<route-one>", RouteHandler).CacheOutput(x => x.Tag("<tag>"));  // tag cache portion
 
@@ -333,11 +333,11 @@ app.MapGet("/<route-two>", (IOutputCacheStore cache, CancellationToken token) =>
 
 ### Custom Cache Policy
 
-```cs linenums="1"
+```cs
 app.MapGet("/<route-one>", RouteHandler).CacheOutput(x => x.AddCachePolicy<CustomCachePolicy>());
 ```
 
-```cs linenums="1"
+```cs
 class CustomCachePolicy : IOutputCachePolicy
 {
     public ValueTask CacheRequestAsync(OutputCacheContext context, CancellationToken cancellationToken) { }
@@ -352,7 +352,7 @@ class CustomCachePolicy : IOutputCachePolicy
 
 The *options pattern* uses classes to provide strongly-typed access to groups of related settings.
 
-```json linenums="1"
+```json
 {
     "SecretKey": "Secret key value",
     "TransientFaultHandlingOptions": {
@@ -369,7 +369,7 @@ The *options pattern* uses classes to provide strongly-typed access to groups of
 }
 ```
 
-```cs linenums="1"
+```cs
 // options model for binding
 public class TransientFaultHandlingOptions
 {
@@ -378,13 +378,13 @@ public class TransientFaultHandlingOptions
 }
 ```
 
-```cs linenums="1"
+```cs
 // setup the options
 builder.Services.Configure<TransientFaultHandlingOptions>(builder.Configuration.GetSection<TransientFaultHandlingOptions>(nameof(Options)));
 builder.Services.Configure<TransientFaultHandlingOptions>(builder.Configuration.GetSection<TransientFaultHandlingOptions>(key));
 ```
 
-```cs linenums="1"
+```cs
 class DependsOnOptions
 {
   private readonly IOptions<TransientFaultHandlingOptions> _options;

docs/languages/dotnet/asp.net/razor-syntax.md

@@ -2,7 +2,7 @@
 
 ## Markup
 
-```cs linenums="1"
+```cs
 @page  // set this as razor page
 
 @model <App>.Models.Entity  // if MVC set type of elements passed to the view 
@@ -35,7 +35,7 @@
 
 Example:
 
-```html linenums="1"
+```html
 <!-- tag helpers for a lin in ASP.NET MVC -->
 <a class="nav-link text-dark" asp-area="" asp-controller="Home" asp-action="Index">Home</a>
 ```
@@ -44,7 +44,7 @@ Example:
 
 The `@addTagHelper` directive makes Tag Helpers available to the view. Generally, the view file is `Pages/_ViewImports.cshtml`, which by default is inherited by all files in the `Pages` folder and subfolders, making Tag Helpers available.
 
-```cs linenums="1"
+```cs
 @using <App>
 @namespace <App>.Pages  // or <Project>.Models
 @addTagHelper *, Microsoft.AspNetCore.Mvc.TagHelpers
@@ -57,7 +57,7 @@ The first parameter after `@addTagHelper` specifies the Tag Helpers to load (`*`
 
 It's possible to disable a Tag Helper at the element level with the Tag Helper opt-out character (`!`)
 
-```cshtml linenums="1"
+```cshtml
 <!-- disable email validation -->
 <!span asp-validation-for="Email" ></!span>
 ```
@@ -66,7 +66,7 @@ It's possible to disable a Tag Helper at the element level with the Tag Helper o
 
 The `@tagHelperPrefix` directive allows to specify a tag prefix string to enable Tag Helper support and to make Tag Helper usage explicit.
 
-```cshtml linenums="1"
+```cshtml
 @tagHelpersPrefix th:
 ```
 
@@ -74,7 +74,7 @@ The `@tagHelperPrefix` directive allows to specify a tag prefix string to enable
 
 [Understanding Html Helpers](https://stephenwalther.com/archive/2009/03/03/chapter-6-understanding-html-helpers)
 
-```cs linenums="1"
+```cs
 @model <App>.Models.Entity
 
 // Display the name of the property
@@ -112,7 +112,7 @@ The `@tagHelperPrefix` directive allows to specify a tag prefix string to enable
 
 In `ViewModel.cs`:
 
-```cs linenums="1"
+```cs
 class ViewModel 
 {
     public int EntityId { get; set; }  // value selected in form ends up here
@@ -126,7 +126,7 @@ class ViewModel
 
 In `View.cs`
 
-```cs linenums="1"
+```cs
 @model ViewModel
 
 <form asp-controller="Controller" asp-action="PostAction">
@@ -140,7 +140,7 @@ In `View.cs`
 
 In `Controller.cs`:
 
-```cs linenums="1"
+```cs
 public IActionResult GetAction()
 {
     var vm = new ViewModel();

docs/languages/dotnet/asp.net/signalr.md

@@ -8,7 +8,7 @@ The SignalR Hubs API enables to call methods on connected clients from the serve
 
 In `Startup.cs`:
 
-```cs linenums="1"
+```cs
 builder.Services.AddSignalR();
 
 var app = builder.Build();
@@ -21,7 +21,7 @@ app.UseEndpoints(endpoints =>
 
 ### Creating Hubs
 
-```cs linenums="1"
+```cs
 public class CustomHub : Hub
 {
     public task HubMethod(Type args)
@@ -46,7 +46,7 @@ A drawback of using `SendAsync` is that it relies on a magic string to specify t
 
 An alternative to using SendAsync is to strongly type the Hub with `Hub<T>`.
 
-```cs linenums="1"
+```cs
 public interface IHubClient
 {
     // matches method to be called on the client
@@ -54,7 +54,7 @@ public interface IHubClient
 }
 ```
 
-```cs linenums="1"
+```cs
 public class CustomHub : Hub<IHubClient>
 {
     public Task HubMethod(Type args)
@@ -72,7 +72,7 @@ Using a strongly typed `Hub<T>` disables the ability to use `SendAsync`. Any met
 
 The SignalR Hubs API provides the OnConnectedAsync and OnDisconnectedAsync virtual methods to manage and track connections. Override the OnConnectedAsync virtual method to perform actions when a client connects to the Hub, such as adding it to a group.
 
-```cs linenums="1"
+```cs
 public override async Task OnConnectedAsync()
 {
     await Groups.AddToGroupAsync(Context.ConnectionId, "GroupName");
@@ -98,7 +98,7 @@ If the Hub throws an exception, connections aren't closed. By default, SignalR r
 
 If you have an exceptional condition you *do* want to propagate to the client, use the `HubException` class. If you throw a `HubException` from your hub method, SignalR will send the entire message to the client, unmodified.
 
-```cs linenums="1"
+```cs
 public Task ThrowException()
 {
     throw new HubException("This error will be sent to the client!");
@@ -109,7 +109,7 @@ public Task ThrowException()
 
 ### Installing the client package
 
-```sh linenums="1"
+```sh
 npm init -y
 npm install @microsoft/signalr
 ```
@@ -118,7 +118,7 @@ npm installs the package contents in the `node_modules\@microsoft\signalr\dist\b
 
 Reference the SignalR JavaScript client in the `<script>` element. For example:
 
-```html linenums="1"
+```html
 <script src="~/lib/signalr/signalr.js"></script>
 ```
 
@@ -126,7 +126,7 @@ Reference the SignalR JavaScript client in the `<script>` element. For example:
 
 [Reconnect Clients Docs](https://docs.microsoft.com/en-us/aspnet/core/signalr/javascript-client#reconnect-clients)
 
-```js linenums="1"
+```js
 const connection = new signalR.HubConnectionBuilder()
     .withUrl("/hub/endpoint")
     .configureLogging(signalR.LogLevel.Information)
@@ -158,7 +158,7 @@ JavaScript clients call public methods on hubs via the `invoke` method of the `H
 - The name of the hub method.
 - Any arguments defined in the hub method.
 
-```js linenums="1"
+```js
 try {
     await connection.invoke("HubMethod", args);
 } catch (err) {
@@ -177,6 +177,6 @@ To receive messages from the hub, define a method using the `on` method of the `
 - The name of the JavaScript client method.
 - Arguments the hub passes to the method.
 
-```cs linenums="1"
+```cs
 connection.on("ClientMethod", (args) => { /* ... */});
 ```

docs/languages/dotnet/asp.net/web-forms.md

@@ -4,7 +4,7 @@
 
 The fist loaded page is `Default.aspx` and its underlying code.
 
-```html linenums="1"
+```html
 <!-- directive -->
 <%@ Page Language="C#" AutoEventWireup="true" CodeBehind="Default.aspx.cs" Inherits="Project.Default" %>
 
@@ -26,7 +26,7 @@ The fist loaded page is `Default.aspx` and its underlying code.
 
 ### Page Directive
 
-```cs linenums="1"
+```cs
 <%@ Page Language="C#"  // define language used (can be C# or VB)
     AutoEventWireup="true"  // automatically create and setup event handlers
     CodeBehind="Default.aspx.cs"  // define the underlying code file
@@ -35,7 +35,7 @@ The fist loaded page is `Default.aspx` and its underlying code.
 
 ### Web Controls
 
-```xml linenums="1"
+```xml
 <asp:Control ID="" runat="server" ...></asp:Control>
 
 <!-- Label: empty text will diplay ID, use empty space as text for empty label -->
@@ -59,7 +59,7 @@ The fist loaded page is `Default.aspx` and its underlying code.
 
 ## `Page.aspx.cs`
 
-```cs linenums="1"
+```cs
 public partial class Default : System.Web.UI.Page
 {
     protected void Page_Load(object sender, EventArgs e)

docs/languages/dotnet/csharp/async-programming.md

@@ -14,7 +14,7 @@ In performance-sensitive code, asynchronous APIs are useful, because instead of
 
 The `async` and `await` keywords in C# are the heart of async programming.
 
-```cs linenums="1"
+```cs
 public async Task<TResult> MethodAsync
 {
     Task<TResult> resultTask = obj.OtherMethodAsync();
@@ -90,7 +90,7 @@ Because `Task` and `Task<TResult>` are **reference types**, memory allocation in
 
 ### Async Composition
 
-```cs linenums="1"
+```cs
 public async Task DoOperationsConcurrentlyAsync()
 {
   Task[] tasks = new Task[3];
@@ -132,7 +132,7 @@ If work starting from a UI thread is performed, but there is no particular need
 If the asynchronous operation is a `Task`, `Task<T>`, `ValueTask` or `ValueTask<T>`, it's possible to discard the *synchronization context* by calling the `ConfigureAwait(false)`.  
 This returns a different representation of the asynchronous operation, and if this iss awaited that instead of the original task, it will ignore the current `SynchronizationContext` if there is one.
 
-```cs linenums="1"
+```cs
 private async Task DownloadFileAsync(string fileName)
 {
   await OperationAsync(fileName).ConfigureAwait(false);  // discarding original context
@@ -156,7 +156,7 @@ This is true even of exceptions thrown before the first `await`.
 If the calling method immediately calls `await` on the return task, this won’t matter much—it will see the exception in any case.  
 But some code may choose not to wait immediately, in which case it won’t see the argument exception until later.
 
-```cs linenums="1"
+```cs
 async Task<string> MethodWithValidationAsync(string argument)
 {
   if(sting.IsNullOrEmpty(argument))
@@ -173,7 +173,7 @@ async Task<string> MethodWithValidationAsync(string argument)
 In cases where you want to throw this kind of exception straightaway, the usual technique is to write a normal method that validates the arguments before calling an async method that does the
 work, and to make that second method either private or local.
 
-```cs linenums="1"
+```cs
 // not marked with async, exception propagate directly to caller
 public static Task<string> MethodWithValidationAsync(string argument)
 {

docs/languages/dotnet/csharp/collections.md

@@ -6,7 +6,7 @@ An array is an object that contains multiple elements of a particular type. The
 
 An array type is always a reference type, regardless of the element type. Nonetheless, the choice between reference type and value type elements makes a significant difference in an array's behavior.
 
-```cs linenums="1"
+```cs
 type[] array = new type[dimension];
 type array[] = new type[dimension];  //invalid
 
@@ -24,7 +24,7 @@ array.OfType<Type>();  // filter array based on type, returns IEnumerable<Type>
 
 ### [Array Methods](https://docs.microsoft.com/en-us/dotnet/api/system.array?view=netcore-3.1#methods)
 
-```cs linenums="1"
+```cs
 // overloaded search methods
 Array.IndexOf(array, item);  // return index of searched item in passed array
 Array.LastIndexOf(array, item); // return index of searched item staring from the end of the array
@@ -54,7 +54,7 @@ C# supports two multidimensional array forms: [jagged][jagg_arrays] arrays and [
 [jagg_arrays]: https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/arrays/jagged-arrays
 [rect_arrays]: https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/arrays/multidimensional-arrays
 
-```cs linenums="1"
+```cs
 //specify first dimension
 type[][] jagged = new type[][]
 {
@@ -87,7 +87,7 @@ matrix.GetLength(int dimension); // get the size of a particular direction
 
 `List<T>` stores sequences of elements. It can grow or shrink, allowing to add or remove elements.
 
-```cs linenums="1"
+```cs
 using System.Collections.Generics;
 
 List<T> list = new List<T>();
@@ -140,7 +140,7 @@ It's possible to use a `yield break` statement or exception to end the iteration
 
 **Note**: Since an iterator returns an `IEnumerable<T>` is can be used to implement a `GetEnumerator()`.
 
-```cs linenums="1"
+```cs
 // simple iterator
 public static System.Collections.IEnumerable<int> IterateRange(int start = 0, int end)
 {
@@ -156,7 +156,7 @@ public static System.Collections.IEnumerable<int> IterateRange(int start = 0, in
 
 Exposes the enumerator, which supports a simple iteration over a collection of a specified type.
 
-```cs linenums="1"
+```cs
 public interface IEnumerable<out T> : IEnumerable
 {
     IEnumerator<T> GetEnumerator();  // return an enumerator
@@ -179,7 +179,7 @@ public interface IEnumerator<T>
 
 ### [`ICollection<T>`](https://docs.microsoft.com/en-us/dotnet/api/system.collections.generic.icollection-1)
 
-```cs linenums="1"
+```cs
 public interface ICollection<T> : IEnumerable<T>
 {
     // properties
@@ -197,7 +197,7 @@ public interface ICollection<T> : IEnumerable<T>
 
 ### [`IList<T>`](https://docs.microsoft.com/en-us/dotnet/api/system.collections.generic.ilist-1)
 
-```cs linenums="1"
+```cs
 public interface IList<T> : ICollection<T>, IEnumerable<T>
 {
     // properties
@@ -228,7 +228,7 @@ public interface IList<T> : ICollection<T>, IEnumerable<T>
 - Enumerating a dictionary will return `KeyValuePair<TKey, TValue>`.
 - The `Dictionary<TKey, TValue>` collection class relies on hashes to offer fast lookup (`TKey` should have a good `GetHashCode()`).
 
-```cs linenums="1"
+```cs
 Dictionary<TKey, TValue> dict = new Dictionary<TKey, TValue>();  // init empty dict
 Dictionary<TKey, TValue> dict = new Dictionary<TKey, TValue>(IEqualityComparer<TKey>);  // specify key comparer (TKey must implement Equals() and GetHashCode())
 
@@ -270,7 +270,7 @@ dict.TryGetValue(key, out var);  // put the value associated with kay in the var
 
 Collection of non duplicate items.
 
-```cs linenums="1"
+```cs
 HashSet<T> set = new HashSet<T>();
 
 set.Add(T); // adds an item to the set; true if the element is added, false if the element is already present.

docs/languages/dotnet/csharp/csharp.md

@@ -18,7 +18,7 @@ to native code later.
 
 ### Comments
 
-```cs linenums="1"
+```cs
 // comment
 /* multi line comment */
 /// single line xml comment (docstring)
@@ -44,7 +44,7 @@ to native code later.
 
 Hierarchic organization of programs an libraries.
 
-```cs linenums="1"
+```cs
 using System;  // import the System Namespace
 using static System.Console;  // statically import a class to use its static methods w/o qualification
 
@@ -65,13 +65,13 @@ namespace Namespace
 
 To enable .NET 6/C# 10 **implicit namespace imports**:
 
-```xml linenums="1"
+```xml
 <ImplicitUsings>enable</ImplicitUsings>
 ```
 
 ### Top Level Statements/Programs (C# 9)
 
-```cs linenums="1"
+```cs
 // imports
 
 // code here, no main, no namespace
@@ -79,7 +79,7 @@ To enable .NET 6/C# 10 **implicit namespace imports**:
 
 ### Main Method
 
-```cs linenums="1"
+```cs
 public static void Main(string[] args)
 {
     // code here
@@ -88,7 +88,7 @@ public static void Main(string[] args)
 
 ### Constant Declaration
 
-```cs linenums="1"
+```cs
 const type CONSTANT_NAME = value;
 ```
 
@@ -100,7 +100,7 @@ If a variable has not been assigned it assumes the `default` value.
 
 ### Input
 
-```cs linenums="1"
+```cs
 // input is a string, convert before saving in a non String variable
 Console.ReadLines();    // read util <Return>  is pressed
 Console.Read();    // read until space
@@ -118,7 +118,7 @@ Console.ReadKey();    // read a key from keyboard and display pressed kay immedi
 
 ### Screen Output
 
-```cs linenums="1"
+```cs
 Console.WriteLine();    // single line output
 ```
 
@@ -126,7 +126,7 @@ Console.WriteLine();    // single line output
 
 `{index[,alignment][:<formatString><num_decimal_digits>]}`
 
-```cs linenums="1"
+```cs
 Console.WriteLine("Name is {0}, Marks are {1}", name, marks);    // string composite formatting
 Console.WriteLine($"Name is {name}, Marks are {marks}");    // string interpolation
 
@@ -200,7 +200,7 @@ The static fields and methods of the `MathF` class correspond to those of the `M
 `BigInteger` represents an integer that will grow as large as is necessary to accommodate values.  
 Unlike the builtin numeric types, it has no theoretical limit on its range.
 
-```cs linenums="1"
+```cs
 using System;
 using System.Numerics;
 
@@ -212,7 +212,7 @@ BigInteger bi;
 Binary literal: `0b<digits>`
 Hexadecimal literal: `0x<digits>`
 
-```cs linenums="1"
+```cs
 // three variables that store the number 2 million
 int decimalNotation = 2_000_000;
 int binaryNotation = 0b_0001_1110_1000_0100_1000_0000;
@@ -232,19 +232,19 @@ int hexadecimalNotation = 0x_001E_8480;
 
 The compiler determines the required type based on the assigned value.
 
-```cs linenums="1"
+```cs
 var variable = value;  // Inferred tipe cant change after first assignment
 ```
 
 ### Dynamic Type
 
-```cs linenums="1"
+```cs
 dynamic variable = value;
 ```
 
 ### Anonymous types (Reference Type)
 
-```cs linenums="1"
+```cs
 // cannot be used as return types
 var x = new { Key = value, ...};  // read only properties
 x.Key;  // member access
@@ -260,7 +260,7 @@ A [System.Range][range_type] represents a range that has start and end indexes.
 [index_type]: https://docs.microsoft.com/en-us/dotnet/api/system.index
 [range_type]: https://docs.microsoft.com/en-us/dotnet/api/system.range
 
-```cs linenums="1"
+```cs
 Index i = position;
 Index i = new Index(position, IsFromEnd: false);  // start-relative index
 
@@ -288,7 +288,7 @@ Tuples are designed as a convenient way to package together a few values in case
 Tuples support comparison, so it's possible to use the `==` and `!=` relational operators.  
 To be considered equal, two tuples must have the same shape and each value in the first tuple must be equal to its counterpart in the second tuple.
 
-```cs linenums="1"
+```cs
 (Type Var1, Type Var2, ...) variable = (value1, value2, ...);
 var variable = (Var1: value1, Var2: value2, ...);  // if name are not supplied they default to Item1, Item2, ...
 var variable = (var1, var2);  // constructed w/ pre-existing values, tuple attributes named after the variables
@@ -296,14 +296,14 @@ var variable = (var1, var2);  // constructed w/ pre-existing values, tuple attri
 
 Since the names of the attributes of a tuple do not matter (a tuple is an instance of `ValueTuple<Type, Type, ...>`) it's possible to assign any tuple to another tuple with the same structure.
 
-```cs linenums="1"
+```cs
 (int X, Int Y) a = (1 , 0);
 (int Width, int Height) b = a;
 ```
 
 ### Tuple Deconstruction
 
-```cs linenums="1"
+```cs
 (int X, int Y) point = (10, 35);
 (int a, int b) = point;  // extract data based on position into two variables
 ```
@@ -312,7 +312,7 @@ Since the names of the attributes of a tuple do not matter (a tuple is an instan
 
 I'ts possible to create record types with immutable properties by using standard property syntax or positional parameters:
 
-```cs linenums="1"
+```cs
 public record Person
 {
     public string FirstName { get; init; } = default!;
@@ -333,7 +333,7 @@ public readonly record struct Point(double X, double Y, double Z);
 
 it's also possible to create record types with mutable properties and fields:
 
-```cs linenums="1"
+```cs
 // mutable record
 public record Person
 {
@@ -361,7 +361,7 @@ While records can be mutable, they're primarily intended for supporting immutabl
 When working with immutable data, a common pattern is to create new values from existing ones to represent a new state.  
 To help with this style of programming, records allow for a new kind of expression; the with-expression.
 
-```cs linenums="1"
+```cs
 var newRecord = oldRecord with { Property = value };
 ```
 
@@ -369,7 +369,7 @@ With-expressions use object initializer syntax to state what's different in the
 A record implicitly defines a protected "copy constructor", a constructor that takes an existing record object and copies it field by field to the new one.  
 The `with` expression causes the copy constructor to get called, and then applies the object initializer on top to change the properties accordingly.
 
-```cs linenums="1"
+```cs
 protected Record(Record original) { /* copy all the fields */ } // generated
 ```
 
@@ -381,7 +381,7 @@ Records have a hidden virtual method that is entrusted with "cloning" the whole
 Every derived record type overrides this method to call the copy constructor of that type, and the copy constructor of a derived record chains to the copy constructor of the base record.  
 A with-expression simply calls the hidden "clone" method and applies the object initializer to the result.
 
-```cs linenums="1"
+```cs
 public record Base{ Type Prop1, Type Prop2 };
 public record Derived : Base { Type Prop3 };
 
@@ -394,7 +394,7 @@ var newBase = @base with { Prop2 = value };  // new Derived record even if type
 Records have a virtual protected property called `EqualityContract`.  
 Every derived record overrides it, and in order to compare equal, the two objects musts have the same `EqualityContract`.
 
-```cs linenums="1"
+```cs
 public record Base{ Type Prop1, Type Prop2 };
 public record Derived : Base { Type Prop3 };
 
@@ -411,7 +411,7 @@ This creates a lot of extra work for .NET's garbage collector, causing the progr
 
 In these situations, it's possible to can use a type called `StringBuilder`. This is conceptually similar to a string but it is modifiable.
 
-```cs linenums="1"
+```cs
 "string contents here"    // string literal
 @"string contents here"    // verbatim string, escape characters printed as-is (raw string literal)
 $"{variable} contents here"    // string interpolation
@@ -422,7 +422,7 @@ String.Length    // returns the length of the string
 
 ### String Methods (Not In-Place)
 
-```cs linenums="1"
+```cs
 string_.IndexOf(<character/string>, startIndex, endIndex);    // index of first occurrence of character/string, -1 otherwise
 string_.LastIndexOf(<character/string>, startIndex, endIndex);    // index last occurrence of character/string, -1 otherwise
 string_.IndexOfAny(char_array, startIndex, endIndex);    // index of any of the characters in the supplied array
@@ -457,7 +457,7 @@ A raw string literal starts with at least three double-quote (`"""`) characters.
 Typically, a raw string literal uses three double quotes on a single line to start the string, and three double quotes on a separate line to end the string.
 The newlines following the opening quote and preceding the closing quote aren't included in the final content:
 
-```cs linenums="1"
+```cs
 
 string longMessage = """
     This is a long message.
@@ -473,7 +473,7 @@ string longMessage = """
 
 Raw string literals can be combined with _string interpolation_ to include braces in the output text. Multiple `$` characters denote how many consecutive braces start and end the interpolation
 
-```cs linenums="1"
+```cs
 var location = $$"""
     You are at {{{Longitude}}, {{Latitude}}}
     """;
@@ -496,7 +496,7 @@ When a nullable type is boxed, the common language runtime automatically boxes t
 
 If the `HasValue` property of a nullable type is `false`, the result of a boxing operation is `null`. Consequently, if a boxed nullable type is passed to a method that expects an object argument, that method must be prepared to handle the case where the argument is `null`. When `null` is unboxed into a nullable type, the common language runtime creates a new `Nullable<T>` structure and initializes its `HasValue` property to `false`.
 
-```cs linenums="1"
+```cs
 Type? nullableValueType = default;  // assigns null
 
 nullableValueType.HasValue  // boolean, use for null check
@@ -548,7 +548,7 @@ Valid settings are:
 
 In `Project.csproj`:
 
-```xml linenums="1"
+```xml
 <Project Sdk="Microsoft.NET.Sdk">
     <PropertyGroup>
         <OutputType>Exe</OutputType>
@@ -562,7 +562,7 @@ In `Project.csproj`:
 
 In `Program.cs`:
 
-```cs linenums="1"
+```cs
 #nullable enable  // Sets the nullable annotation context and nullable warning context to enabled.
 #nullable disable  // Sets the nullable annotation context and nullable warning context to disabled.
 #nullable restore  // Restores the nullable annotation context and nullable warning context to the project settings.
@@ -576,7 +576,7 @@ In `Program.cs`:
 
 ### Null Conditional, Null Coalescing, Null Forgiving Operator, Null Checks
 
-```cs linenums="1"
+```cs
 Type? variable = null;  // the variable can also contain the NULL value (nullable type)
 
 <expr>!  // declare explicitly that the expression is not null (null forgiving operator)
@@ -627,7 +627,7 @@ That information helps the compiler perform static analysis and determine when a
 
 ## Type Conversion
 
-```cs linenums="1"
+```cs
 variable.GetType();  // System type of variable
 
 (type) variable  // explicit conversion
@@ -680,7 +680,7 @@ The _.NET SDK_ defines certain symbols by default. It supports two configuration
 It defines a `DEBUG` compilation symbol in the Debug configuration, whereas Release will define `RELEASE` instead.  
 It defines a symbol called `TRACE` in both configurations.
 
-```cs linenums="1"
+```cs
 #if DEBUG
     // instructions
 #endif
@@ -690,7 +690,7 @@ C# provides a more subtle mechanism to support this sort of thing, called a _con
 The compiler recognizes an attribute defined by the .NET class libraries, called `ConditionalAttribute`, for which it provides special compile time behavior.  
 Method annotated with this attribute will not be present in a non-Debug release.
 
-```cs linenums="1"
+```cs
 [System.Diagnostics.Conditional("DEBUG")]
 Type Method() { ... }
 ```
@@ -699,7 +699,7 @@ Type Method() { ... }
 
 C# allows choose to generate _compiler errors_ or warnings with the `#error` and `#warning` directives. These are typically used inside conditional regions.
 
-```cs linenums="1"
+```cs
 #if NETSTANDARD
     #error .NET Standard is not a supported target for this source file
 #endif
@@ -710,7 +710,7 @@ C# allows choose to generate _compiler errors_ or warnings with the `#error` and
 The `#pragma` directive provides two features: it can be used to disable selected compiler warnings, and it can also be used to override the checksum values the compiler puts into the `.pdb` file it generates containing debug information.  
 Both of these are designed primarily for code generation scenarios, although they can occasionally be useful to disable warnings in ordinary code.
 
-```cs linenums="1"
+```cs
 #pragma warning disable CS<number>
 ```
 
@@ -809,7 +809,7 @@ Both of these are designed primarily for code generation scenarios, although the
 
 ### `If`-`Else If`-`Else`
 
-```cs linenums="1"
+```cs
 Object o;
 
 if (condition)
@@ -832,7 +832,7 @@ else
 
 A pattern describes one or more criteria that a value can be tested against. It's usable in switch statements, switch expressions and if statements.
 
-```cs linenums="1"
+```cs
 // type pattern
 <expr> is Type t  // type pattern
 
@@ -885,7 +885,7 @@ The `when` keyword can be used to specify a filter condition that causes its ass
 
 [Switch Expressions](https://dotnetcoretutorials.com/2019/06/25/switch-expressions-in-c-8/)
 
-```cs linenums="1"
+```cs
 switch (expr)
 {
     // multiple labels for same block
@@ -924,7 +924,7 @@ variable switch
 
 ### `While` Loop
 
-```cs linenums="1"
+```cs
 while (condition)
 {
     // code here
@@ -935,7 +935,7 @@ while (condition)
 
 Executes at least one time.
 
-```cs linenums="1"
+```cs
 do
 {
     // code here
@@ -945,7 +945,7 @@ while (condition);
 
 ### `For` Loop
 
-```cs linenums="1"
+```cs
 for (initializer; condition; iterator)
 {
     // code here
@@ -962,7 +962,7 @@ Technically, the `foreach` statement will work on any type that follows these ru
 
 There are interfaces named `IEnumerable` and `IEnumerable<T>` that formally define these rules but technically the compiler does not require the type to implement these interfaces.
 
-```cs linenums="1"
+```cs
 foreach (type item in iterabile)
 {
     // code here
@@ -974,7 +974,7 @@ foreach (type item in iterabile)
 
 Example:
 
-```cs linenums="1"
+```cs
 // make integers enumerable
 public static IEnumerator<int> GetEnumerator(this int source)
 {
@@ -992,14 +992,14 @@ public static IEnumerator<int> GetEnumerator(this int source)
 
 ### Yield Statement
 
-```cs linenums="1"
+```cs
 yield return <expression>;    // returns the results one at a time.
 yield break;    // concludes the iteration
 ```
 
 ### Context Statement & Using Declarations
 
-```cs linenums="1"
+```cs
 using (Type obj = new Type())  // obj disposed at the end of the using block
 {
     // code here
@@ -1023,7 +1023,7 @@ It is done by editing the `.csproj` file, adding `<CheckForOverflowUnderflow>tru
 
 > **Note**: checking can make individual integer operations several times slower.
 
-```cs linenums="1"
+```cs
 checked
 {
     // code here
@@ -1045,7 +1045,7 @@ unchecked(<expr>);
 
 [Exception Object](https://docs.microsoft.com/en-us/dotnet/api/system.exception)
 
-```cs linenums="1"
+```cs
 try
 {
     // "dangerous" code
@@ -1071,7 +1071,7 @@ finally
 
 ### Throwing Exceptions
 
-```cs linenums="1"
+```cs
 throw new ExceptionClass();
 throw new ExceptionClass("message");
 
@@ -1092,7 +1092,7 @@ Environment.FailFast(causeOfFailure);
 
 ### Custom Exceptions
 
-```cs linenums="1"
+```cs
 public class CustomException : Exception  // must derive from Exception (either directly or indirectly)
 {
     public CustomException()
@@ -1118,7 +1118,7 @@ public class CustomException : Exception  // must derive from Exception (either
 An enumeration type (or enum type) is a value type defined by a set of **named constants** of the underlying _integral numeric_ type (`int`, `long`, `byte`, ...).  
 Consecutive names increase the value by one.
 
-```cs linenums="1"
+```cs
 [Flags]  // indicate that the flag can be combined (best if values are binary) as a bit mask
 enum EnumType : IntegralNumericType // named values MUST match IntegerNumericType allowed values
 {
@@ -1153,7 +1153,7 @@ The method signature is the number & type of the input parameters defined for th
 C# makes the fairly common distinction between _parameters_ and _arguments_: a method defines a list of the inputs it expects (the parameters) and the code inside the method refers to these parameters by name.  
 The values seen by the code could be different each time the method is invoked, and the term argument refers to the specific value supplied for a parameter in a particular invocation.
 
-```cs linenums="1"
+```cs
 type MethodName (type parameter, ...)
 {
     // code here
@@ -1168,13 +1168,13 @@ void MethodName (type parameter, ...) {
 
 ### Expression Body Definition
 
-```cs linenums="1"
+```cs
 type MethodName() => <expression>;    // expression result type MUST match method type
 ```
 
 ### Arbitrary Number Of Parameter In Methods
 
-```cs linenums="1"
+```cs
 // params keyword must be last parameter and must be an array
 type MethodName (type parameter, params type[] args)
 {
@@ -1184,7 +1184,7 @@ type MethodName (type parameter, params type[] args)
 
 ### [Named Arguments](https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/named-and-optional-arguments#named-arguments)
 
-```cs linenums="1"
+```cs
 type MethodName (type param1, type param2, ...) { }
 
 MethodName(param1: value, param2: value);
@@ -1208,7 +1208,7 @@ A default value must be one of the following types of expressions:
 - an expression of the form new ValType(), where ValType is a value type, such as an enum or a struct;
 - an expression of the form default(ValType), where ValType is a value type.
 
-```cs linenums="1"
+```cs
 type MethodName (type required, type firstOptional = default_value, type secondOptional = default_value, ...) { }
 MethodName(value1);  // use defaults for optional arguments
 MethodName(required: value, secondOptional: value);  // use default for first optional but pass second optional
@@ -1241,7 +1241,7 @@ Use cases:
 While the method can use members of the passed reference type, it can't normally replace it with a different object.  
 But if a reference type argument is marked with ref, the method has access to the variable, so it could replace it with a reference to a completely different object.
 
-```cs linenums="1"
+```cs
 // method declaration
 type MethodName (type param1,  ref type param2, out type param3, in type param4, ...)
 {
@@ -1261,7 +1261,7 @@ OutMethod(arg1, out var arg2);  // create out variable on the fly
 **Must** be C# 7+.  
 The retuned tuple MUST match the tuple-type in the instantiation
 
-```cs linenums="1"
+```cs
 (type returnedVar1, type returnedVar2, ...) MethodName (type parameter, ...)
 {
    // code here
@@ -1271,7 +1271,7 @@ The retuned tuple MUST match the tuple-type in the instantiation
 
 ### Returning Multiple Values W/ Structs (Return Struct Variable)
 
-```cs linenums="1"
+```cs
 StructName MethodName (args)
 {
    // code here
@@ -1285,7 +1285,7 @@ StructName MethodName (args)
 
 ### Local Functions
 
-```cs linenums="1"
+```cs
 type OuterMethod(...)
 {
     var foo = InnerMethod();
@@ -1302,7 +1302,7 @@ It's just an illusion maintained by the C# compiler, one that it keeps up even i
 
 > **Note**: Extension Method can be declared only inside static classes. Extension methods are available only if their namespace is imported with the `using` keyword.
 
-```cs linenums="1"
+```cs
 public static class ExtensionMethods
 {
     type ExtensionMethod(this type param)
@@ -1328,7 +1328,7 @@ It's possible to use a `yield break` statement or exception to end the iteration
 
 > **Note**: Since an iterator returns an `IEnumerable<T>` is can be used to implement a `GetEnumerator()`.
 
-```cs linenums="1"
+```cs
 // simple iterator
 public static System.Collections.IEnumerable<int> IterateRange(int start = 0, int end)
 {
@@ -1361,7 +1361,7 @@ Modifiable value types tend to be problematic, because it's all too easy to end
 So it's usually a good idea for value types to be immutable. This doesn't mean that variables of these types cannot be modified;  
 it just means that to modify the variable, its contents must be replaced entirely with a different value.
 
-```cs linenums="1"
+```cs
 public struct Point
 {
     public Point(double x, double y)
@@ -1390,7 +1390,7 @@ If you attempt to access the variable outside of the code block, you'll get a co
 
 [Access Modifiers](https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/access-modifiers)
 
-```cs linenums="1"
+```cs
 // ACCESS MODIFIERS
 public    // visible from everywhere
 private    // not visible outside of the class (default for members)
@@ -1424,7 +1424,7 @@ If any part declares a base type, then the whole type inherits that class.
 
 ### Methods
 
-```cs linenums="1"
+```cs
 class Class
 {
     static Type Method(Type Argument, ...) {}  // static method, can operate ONLY on STATIC VARIABLES
@@ -1473,7 +1473,7 @@ class Class(Type Parameter, ...)  // primary constructor (like records)
 A _field_ is a variable of any type that is declared directly in a class or struct. Fields are members of their containing type.  
 A _property_ is a member that provides a flexible mechanism to read, write, or compute the value of a private field.
 
-```cs linenums="1"
+```cs
 class Class
 {
 
@@ -1531,7 +1531,7 @@ Because `init` accessors can only be called during initialization, they are allo
 **Object initializers** allow to assign values to any accessible fields or properties of an object at creation time without having to invoke a constructor followed by lines of assignment statements.  
 The object initializer syntax enables to specify arguments for a constructor or omit the arguments (and parentheses syntax).
 
-```cs linenums="1"
+```cs
 public class Class
 {
     // Auto-implemented properties.
@@ -1563,7 +1563,7 @@ Class obj = new Class(arg1) { Prop2 = arg2 };  // w/ constructor
 var copy = original with { Prop = newValue };  // other props are copies of the original
 ```
 
-```cs linenums="1"
+```cs
 public class Matrix
 {
     private double[,] matrix = new double[3, 3];
@@ -1631,7 +1631,7 @@ Dictionary<int, string> digits = [
 The `static` keyword declares that a member is not associated with any particular instance of the class.  
 Static classes **can't** instantiate objects and all their methods **must** be static.
 
-```cs linenums="1"
+```cs
 static class Class
 {
     // static constructor, not called explicitly, has no arguments
@@ -1672,7 +1672,7 @@ static class Class
 An **indexer** is a property that takes one or more arguments, and is accessed with the same syntax as is used for arrays.  
 This is useful when writing a class that contains a collection of objects.
 
-```cs linenums="1"
+```cs
 public class Class<T>
 {
     public T this[int i]
@@ -1718,7 +1718,7 @@ Members marked as `abstract` must be implemented by non-abstract classes that de
 - It is an error to use the `abstract` modifier on a `static` property.
 - An `abstract` inherited property can be overridden in a derived class by including a property declaration that uses the `override` modifier.
 
-```cs linenums="1"
+```cs
 public abstract class Abstract : Interface
 {
     public abstract Type Property { get; set; }
@@ -1743,7 +1743,7 @@ public class Derived : Abstract
 
 ### Cloning
 
-```cs linenums="1"
+```cs
 Class obj = new Class()
 
 Object.MemberwiseClone();  // Returns shallow copy of the object
@@ -1756,7 +1756,7 @@ Deconstruction is not limited to tuples. By providing a `Deconstruct(...)` metho
 
 > **Note**: Types with a deconstructor can also use _positional pattern matching_.
 
-```cs linenums="1"
+```cs
 public readonly struct Size
 {
     public Size(double w, double h)
@@ -1809,7 +1809,7 @@ Use the operator keyword to declare an operator. An operator declaration must sa
 
 [Overloadable operators](https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/operators/operator-overloading#overloadable-operators)
 
-```cs linenums="1"
+```cs
 using System;
 
 public readonly struct Fraction
@@ -1899,7 +1899,7 @@ An interface is effectively a list of the members that a type will need to provi
 
 C# 8.0 adds the ability to define default implementations for some or all methods, and also to define nested types and static fields.
 
-```cs linenums="1"
+```cs
 // can only be public or internal if not nested, any accessibility otherwise
 public interface IContract
 {
@@ -1956,7 +1956,7 @@ which is effectively an object that holds a copy of a struct in a way that can b
 [Generics Docs](https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/generics/)
 [Generic Methods Docs](https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/generics/generic-methods)
 
-```cs linenums="1"
+```cs
 // type parameter T in angle brackets
 // WARNING: T is not instantiable, new t(), new t[] are INVALID
 public class GenericClass<T> {
@@ -1983,7 +1983,7 @@ obj.GenericMethodName(Type param);  // type deduced by input, input type and gen
 
 ### Multiple Generics
 
-```cs linenums="1"
+```cs
 public class GenericClass<T1, T2, ...> { }  // number of generic types is not limited
 ```
 
@@ -2000,7 +2000,7 @@ C# supports only six kinds of constraints on a type argument:
 - `unmanaged`
 - `new()`
 
-```cs linenums="1"
+```cs
 // type constraints
 public class GenericClass<T> where T : Interface { }
 public class GenericClass<T> where T: GenericClass { }
@@ -2049,7 +2049,7 @@ both public and private—an instance of the derived class can do anything an in
 > **Note**: When deriving from a class, it's not possible to make the derived class more visible than its base. This restriction does not apply to interfaces.  
 A `public` class is free to implement `internal` or `private` interfaces. However, it does apply to an interface's bases: a `public` interface cannot derive from an `internal` interface.
 
-```cs linenums="1"
+```cs
 class BaseClass
 {
     public virtual Property { get; set; }
@@ -2074,7 +2074,7 @@ class ChildClass : BaseClass, Interface, Interface<Type>
 
 Downcasting is the conversion from a base class type to one of it's derived types.
 
-```cs linenums="1"
+```cs
 Base b;
 var d = (Derived) b;  // explicit casting (if conversion fails throws InvalidCastException)
 var d = b as Derived;  // as operator (if conversion fails AS will return NULL)
@@ -2095,7 +2095,7 @@ Initialization order:
 3. Base class constructor
 4. Derived class constructor
 
-```cs linenums="1"
+```cs
 public class Base
 {
     public Base(Type param) {}
@@ -2113,7 +2113,7 @@ public class Derived
 If you derive from a generic class, you must supply the type arguments it requires.  
 You must provide concrete types unless your derived type is generic, in which case it can use its own type parameters as arguments.
 
-```cs linenums="1"
+```cs
 public class GenericBase1<T>
 {
     public T Item { get; set; }
@@ -2132,7 +2132,7 @@ public class MixedDerived<T> : GenericBase2<T, Type>  // derived is generic but
 
 It's allowed to use derived type as a type argument to the base class. And it's also possible to specify a constraint on a type argument requiring it to derive from the derived type.
 
-```cs linenums="1"
+```cs
 public class Derived : base<Derived> {}
 public class Derived<T> where T : Derived<T>
 ```
@@ -2152,7 +2152,7 @@ Generic type parameters support covariance and contravariance to provide greater
 
 > **Note**: annotate generic type parameters with `out` and `in` annotations to specify whether they should behave covariantly or contravariantly.
 
-```cs linenums="1"
+```cs
 public class Base {};
 public class Derived : Base {}
 
@@ -2194,7 +2194,7 @@ This ability to refer to a method as a parameter makes delegates ideal for defin
 Any method from any accessible class or struct that matches the delegate type can be assigned to the delegate. The method can be either static or an instance method.  
 This makes it possible to programmatically change method calls, and also plug new code into existing classes.
 
-```cs linenums="1"
+```cs
 // delegate definition
 public delegate Type Delegate(Type param, ...);  // can take any method with specified type params and return type
 public delegate Type Delegate<T>(T param);  // generic delegate
@@ -2208,7 +2208,7 @@ Delegate<Type> delegate = Method;  // implicit creation
 
 **Multicast Delegates** are delegates that can have more than one element in their invocation list.
 
-```cs linenums="1"
+```cs
 Delegate<Type> multicastDelegate = Method1 + Method2 + ...;  // multicast delegate creation
 multicastDelegate += Method;  // add method to delegate
 multicastDelegate -= Method;  // remove method from delegate
@@ -2222,7 +2222,7 @@ Subtraction of a multicast delegate succeeds only if the delegate from which sub
 Invoking a delegate with a single target method works as though the code had called the target method in the conventional way.  
 Invoking a multicast delegate is just like calling each of its target methods in turn.
 
-```cs linenums="1"
+```cs
 Delegate<Type> delegate = Method;
 
 delegate(args);  // use delegate as standard method
@@ -2235,7 +2235,7 @@ multicastDelegate.GetInvocationList();  // list of methods called by the delegat
 
 > **Note**: Each delegate has an overload taking from zero to 16 arguments;
 
-```cs linenums="1"
+```cs
 public delegate void Action<in T1, ...>(T1 arg1, ...);
 public delegate TResult Func<in T1, ..., out TResult>(T1 arg1, ...);
 public delegate bool Predicate<in T1, ...>(T1 arg1, ...);
@@ -2250,7 +2250,7 @@ However, the type system supports certain implicit reference conversions for gen
 
 Delegates without explicit separated method.
 
-```cs linenums="1"
+```cs
 // lambda variations
 Delegate<Type> lambda = () => <expr>;
 Delegate<Type> lambda = input => <expr>;
@@ -2288,7 +2288,7 @@ Structs and classes can declare events. This kind of member enables a type to pr
 The class who raises events is called _Publisher_, and the class who receives the notification is called _Subscriber_. There can be multiple subscribers of a single event.  
 Typically, a publisher raises an event when some action occurred. The subscribers, who are interested in getting a notification when an action occurred, should register with an event and handle it.
 
-```cs linenums="1"
+```cs
 public delegate void EventDelegate(object sender, CustomEventArgs args);  // called on event trigger
 
 public class Publisher
@@ -2305,7 +2305,7 @@ public class Publisher
 
 ### Registering Event Handlers
 
-```cs linenums="1"
+```cs
 public class Subscriber
 {
     Publisher publisher = new Publisher();
@@ -2326,7 +2326,7 @@ public class Subscriber
 Typically, any event should include two parameters: the _source_ of the event and event _data_.  
 The `EventHandler` delegate is used for all events that do not include event data, the `EventHandler<TEventArgs>` delegate is used for events that include data to be sent to handlers.
 
-```cs linenums="1"
+```cs
 public class Publisher
 {
     public event EventHandler Event;
@@ -2352,7 +2352,7 @@ public class Subscriber
 
 ### Custom Event Args
 
-```cs linenums="1"
+```cs
 public class CustomEventArgs : EventArgs { }
 
 public class Publisher
@@ -2533,7 +2533,7 @@ To be used as an attribute, a type must derive from the `System.Attribute` class
 
 It's possible to pass arguments to the attribute _constructor_ in the annotation.
 
-```cs linenums="1"
+```cs
 [AttName]  // simple attribute
 
 [AttName(value)]  // valorize private fields (through the constructor)
@@ -2544,7 +2544,7 @@ It's possible to pass arguments to the attribute _constructor_ in the annotation
 
 ### Multiple Attributes
 
-```cs linenums="1"
+```cs
 [Attribute1]
 [Attribute2]
 
@@ -2553,7 +2553,7 @@ It's possible to pass arguments to the attribute _constructor_ in the annotation
 
 ### Defining Custom Attribute Types
 
-```cs linenums="1"
+```cs
 // specify what the attribute can be applied to (enforced by c# compiler)
 [AttributeUsage(AttributeTargets.<TargetType>)]
 public class CustomAttribute : Attribute
@@ -2571,7 +2571,7 @@ public class CustomAttribute : Attribute
 It's possible to discover which attributes have been applied through the reflection API.  
 The various targets of attribute have a reflection type representing them (`MethodInfo`, `PropertyInfo`, ...) which all implement the interface `ICustomAttributeProvider`.
 
-```cs linenums="1"
+```cs
 public interface ICustomAttributeProvider
 {
     object[] GetCustomAttributes(bool inherit);
@@ -2590,7 +2590,7 @@ A console application uses streams to represent its input and output.
 The `Stream` class is defined in the `System.IO` namespace.  
 It is an abstract base class, with concrete derived types such as `FileStream` or `GZipStream` representing particular kinds of streams.
 
-```cs linenums="1"
+```cs
 // The most important members of Stream
 public abstract int Read(byte[] buffer, int offset, int count);
 public abstract void Write(byte[] buffer, int offset, int count);
@@ -2619,7 +2619,7 @@ This is not guaranteed to work because it's not always possible to support it. S
 Stream also defines a Seek method, this allows to specify the position required relative to the stream's current position.  
 Passing `SeekOrigin.Current` as second argument will set the position by adding the first argument to the current position.
 
-```cs linenums="1"
+```cs
 public abstract long Seek(long offset, SeekOrigin origin);  // offset can be negative
 ```
 
@@ -2650,7 +2650,7 @@ It's possible to constructing them by passing a `Stream` as a constructor argume
 
 [Encoding](https://docs.microsoft.com/en-us/dotnet/api/system.text.encoding)
 
-```cs linenums="1"
+```cs
 // Will detect encoding from stream contents
 StreamReader file = new StreamReader(string path);
 StreamReader file = new StreamReader(string path, System.Text.Encoding encoding);  // encoding is System.Text.Encoding
@@ -2697,7 +2697,7 @@ The `FileStream` class derives from `Stream` and represents a file from the file
 It' common to use the constructors in which the `FileStream` uses OS APIs to create the file handle. It's possible to provide varying levels of detail on how this si to be done.  
 At a minimum the file's path and a value from the `FileMode` enumeration must be provided.
 
-```cs linenums="1"
+```cs
 // overloaded FileStream Constructors
 public FileStream(string path, FileMode mode);
 public FileStream(string path, FileMode mode, FileAccess access);
@@ -2741,7 +2741,7 @@ public FileStream(string path, FileMode mode, FileAccess access, FileShare share
 
 > **Note**: The `WriteThrough` flag will ensure that when the stream is disposed or flushed, all the data written will have been delivered to the drive, but the drive will not necessarily have written that data persistently (drives can defer writing for performance), so data loss id still possible if the power fails.
 
-```cs linenums="1"
+```cs
 // object to read or write to a file (file can be binary)
 {
     using(FileStream fstream = new FileStream(path, FileMode.OpenOrCreate, FileAccess.ReadWrite))
@@ -2755,7 +2755,7 @@ public FileStream(string path, FileMode mode, FileAccess access, FileShare share
 
 The static `File` class provides methods for performing various operations on files.
 
-```cs linenums="1"
+```cs
 File.Create(string path);  // Return Read/Write FileStream to file
 File.Open(string path, System.IO.FileMode mode);  // Open a FileStream on the specified path with read/write access with no sharing.
 File.Open(string path, System.IO.FileMode mode, System.IO.FileAccess access);  // Opens a FileStream on the specified path, with the specified mode and access with no sharing.
@@ -2795,7 +2795,7 @@ File.Replace(string sourceFileName, string destinationFileName, string destinati
 
 Exposes static methods for creating, moving, and enumerating through directories and subdirectories.
 
-```cs linenums="1"
+```cs
 Directory.CreateDirectory(string path);  // Create directory as specified
 Directory.Delete(string path);  // Delete an empty directory from a specified path (dir must be writable)
 Directory.Delete(string path, bool recursive);  // Delete the specified directory and, if indicated, any subdirectories and files in the directory
@@ -2823,7 +2823,7 @@ Directory.GetFileSystemEntries (string path, string searchPattern, SearchOption
 
 ### [Path](https://docs.microsoft.com/en-us/dotnet/api/system.io.path) Class
 
-```cs linenums="1"
+```cs
 Combine(string path1, string path2);  // Combine two strings into a path
 Combine(string[] paths);  // Combine strings into a path
 
@@ -2870,7 +2870,7 @@ Classes to hold multiple info about a file or directory. If some property change
 
 Types are required to opt into CLR serialization. .NET defines a `[Serializable]` attribute that must be present before the CLR will serialize the type (class).
 
-```cs linenums="1"
+```cs
 [Serializable]
 class Class { }
 ```
@@ -2887,7 +2887,7 @@ Serialization works directly with an object's fields. It uses reflection, which
 
 Object that represents the difference between two dates
 
-```cs linenums="1"
+```cs
 TimeSpan Interval = new DateTime() - new DateTime()  // difference between dates
 
 // constructors
@@ -2920,7 +2920,7 @@ length.
 
 Access to a span contents is done like an and since a `Span<T>` knows its own length, its indexer checks that the index is in range, just as the built-in array type does.
 
-```cs linenums="1"
+```cs
 Span<int> numbers = stackalloc int[] { 1, 2, 3 };
 var first = numbers[0];
 ```
@@ -2960,7 +2960,7 @@ This makes these memory types useful when you want something span-like, but in a
 
 [regex reference](https://docs.microsoft.com/en-us/dotnet/standard/base-types/regular-expression-language-quick-reference)
 
-```cs linenums="1"
+```cs
 Match match = Regex.Match(string, pattern, regexOptions);
 
 match.Success;  // whether there was a match or not
@@ -2997,7 +2997,7 @@ The `fixed` statement sets a pointer to a managed variable and "pins" that varia
 Pointers to movable managed variables are useful only in a fixed context. Without a fixed context, garbage collection could relocate the variables unpredictably.  
 The C# compiler only allows to assign a pointer to a managed variable in a fixed statement.
 
-```cs linenums="1"
+```cs
 unsafe Type UnsafeMethod() { /* unsafe context */ }
 // or
 unsafe
@@ -3023,7 +3023,7 @@ unsafe
 
 ### Native Memory
 
-```cs linenums="1"
+```cs
 using System.Runtime.InteropServices;
 
 unsafe
@@ -3040,7 +3040,7 @@ The `extern` modifier is used to declare a method that is implemented externally
 A common use of the extern modifier is with the `DllImport` attribute when using Interop services to call into _unmanaged_ code.  
 In this case, the method must also be declared as `static`.
 
-```cs linenums="1"
+```cs
 [DllImport("avifil32.dll")]
 private static extern void AVIFileInit();
 ```
@@ -3051,14 +3051,14 @@ Methods needed to implement a behaviour which do not need an interface to work.
 
 ### Enumerable
 
-```cs linenums="1"
+```cs
 public bool MoveNext(/* ... */);
 public T Current { get; }
 ```
 
 ### Awaitable
 
-```cs linenums="1"
+```cs
 public TaskAwaiter GetAwaiter(/* ... */);
 ```
 

docs/languages/dotnet/csharp/linq.md

@@ -13,7 +13,7 @@ LINQ to Objects will be used when any `IEnumerable<T>` is specified as the sourc
 All query expressions are required to begin with a `from` clause, which specifies the source of the query.  
 The final part of the query is a `select` (or `group`) clause. This determines the final output of the query and its system type.
 
-```cs linenums="1"
+```cs
 // query expression
 var result = from item in enumerable select item;
 
@@ -35,7 +35,7 @@ var result = from item in enumerable group item by item.property;  // returns IE
 The compiler converts all query expressions into one or more method calls. Once it has done that, the LINQ provider is selected through exactly the same mechanisms that C# uses for any other method call.  
 The compiler does not have any built-in concept of what constitutes a LINQ provider.
 
-```cs linenums="1"
+```cs
 // expanded query expression
 var result = Enumerable.Where(item => condition).Select(item => item);
 ```
@@ -44,7 +44,7 @@ The `Where` and `Select` methods are examples of LINQ operators. A LINQ operator
 
 ### Methods on `Enumerable` or `IEnumerable<T>`
 
-```cs linenums="1"
+```cs
 Enumerable.Range(int start, int end);  // IEnumerable<int> of values between start & end
 
 IEnumerable<TSource>.Select(Func<TSource, TResult> selector);  // map
@@ -77,7 +77,7 @@ IEnumerable<TFirst>.Zip(IEnumerable<TSecond> enumerable); // Produces a sequence
 
 > **Note**: `Enumerable` provides a set of `static` methods for querying objects that implement `IEnumerable<T>`. Most methods are extensions of `IEnumerable<T>`
 
-```cs linenums="1"
+```cs
 Enumerable.Method(IEnumerable<T> source, args);
 // if extension method same as
 IEnumerable<T>.Method(args);

docs/languages/dotnet/csharp/reactive-extensions.md

@@ -19,7 +19,7 @@ Because Rx implements standard LINQ operators, it's possible to write queries ag
 The two most important types in Rx are the `IObservable<T>` and `IObserver<T>` interfaces.  
 They are important enough to be in the System namespace. The other parts of Rx are in the `System.Reactive` NuGet package.
 
-```cs linenums="1"
+```cs
 public interface IObservable<out T>
 {
     IDisposable Subscribe(IObserver<T> observer);

docs/languages/dotnet/csharp/unit-tests.md

@@ -5,7 +5,7 @@
 
 ## xUnit
 
-```cs linenums="1"
+```cs
 using System;
 using Xunit;
 
@@ -37,7 +37,7 @@ For context cleanup, add the `IDisposable` interface to the test class, and put
 
 ## Mocking with Moq
 
-```cs linenums="1"
+```cs
 var mockObj = new Mock<MockedType>();
 
 mockObj.Setup(m => m.Method(It.IsAny<InputType>())).Returns(value);

docs/languages/dotnet/database/ado.net.md

@@ -27,7 +27,7 @@ The `ADO.NET` classes are found in `System.Data.dll`, and are integrated with th
 
 ## Connection to DB
 
-```cs linenums="1"
+```cs
 using System;
 using System.Data.SqlClient;  // ADO.NET Provider, installed through NuGet
 
@@ -55,7 +55,7 @@ namespace <namespace>
 
 ### `SqlConnection`
 
-```cs linenums="1"
+```cs
 using (SqlConnection connection = new SqlConnection())
 {
     connection.ConnectionString = connectionString.ConnectionString;
@@ -70,7 +70,7 @@ using (SqlConnection connection = new SqlConnection(connectionString)) {
 
 ### [SqlCommand](https://docs.microsoft.com/en-us/dotnet/api/system.data.sqlclient.sqlcommand)
 
-```cs linenums="1"
+```cs
 string sql = "<sql_instruction>";
 
 using (SqlCommand command = new SqlCommand())
@@ -94,7 +94,7 @@ using (SqlCommand command = new SqlCommand())
 
 ### `SqlDataReader`
 
-```cs linenums="1"
+```cs
 using (SqlDataReader cursor = command.ExecuteReader())  // object to get data from db
 {
     while (cursor.Read())  // get data till possible

docs/languages/dotnet/database/entity-framework.md

@@ -2,7 +2,7 @@
 
 ## Model & Data Annotations
 
-```cs linenums="1"
+```cs
 using System;
 using System.Collections.Generic;
 using System.ComponentModel.DataAnnotations;
@@ -35,7 +35,7 @@ NuGet Packages to install:
 - `Microsoft.EntityFrameworkCore.Design` *or* `Microsoft.EntityFrameworkCore.<db_provider>.Design` needed for tools to work (bundled w\ tools)
 - `Microsoft.EntityFrameworkCore.<db_provider>`
 
-```cs linenums="1"
+```cs
 using Microsoft.EntityFrameworkCore;
 
 namespace <Project>.Model
@@ -69,14 +69,14 @@ Create & Update DB Schema if necessary.
 
 In Package Manager Shell:
 
-```ps1 linenums="1"
+```ps1
 PM> Add-Migration <migration_name>
 PM> update-database [-Verbose] # use the migrations to modify the db, -Verbose to show SQL queries
 ```
 
 In dotnet cli:
 
-```ps1 linenums="1"
+```ps1
 dotnet tool install --global dotnet-ef  # if not already installed
 
 dotnet ef migrations add <migration_name>
@@ -87,7 +87,7 @@ dotnet ef database update
 
 ### Create
 
-```cs linenums="1"
+```cs
 context.Add(entity);
 context.AddRange(entities);
 
@@ -98,7 +98,7 @@ context.SaveChanges();
 
 [Referenced Object Not Loading Fix](https://stackoverflow.com/a/5385288)
 
-```cs linenums="1"
+```cs
 context.Entities.ToList();
 context.Entities.Find(id);
 
@@ -108,7 +108,7 @@ context.Entities.Include(c => c.ForeignObject).Find(id);
 
 ### Update
 
-```cs linenums="1"
+```cs
 context.Entities.Update(entity);
 context.UpdateRange(entities);
 
@@ -117,7 +117,7 @@ context.SaveChanges();
 
 ### Delete
 
-```cs linenums="1"
+```cs
 context.Entities.Remove(entity);
 context.RemoveRange(entities);
 

docs/languages/html/html.md

@@ -26,14 +26,14 @@ The first thing on an HTML page is the doctype, which tells the browser which ve
 
 ### XHTML 1.0 Strict
 
-```html linenums="1"
+```html
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
 ```
 
 ### HTML4 Transitional
 
-```html linenums="1"
+```html
 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
  "http://www.w3.org/TR/html4/loose.dtd">
 ```
@@ -46,7 +46,7 @@ The first thing on an HTML page is the doctype, which tells the browser which ve
 
 After `<doctype>`, the page content must be contained between tags.
 
-```html linenums="1"
+```html
 <!doctype html>
 <html lang="en">
     <!-- page contents -->
@@ -66,7 +66,7 @@ HTML5: `<meta charset="utf-8">`
 
 Used to make old browsers understand newer HTML5 and newer components.
 
-```html linenums="1"
+```html
 <!--[if lt IE 9]>
     <script src="https://cdnjs.cloudflare.com/ajax/libs/html5shiv/3.7.3/html5shiv.js"></script>
 <![endif]-->
@@ -76,7 +76,7 @@ Used to make old browsers understand newer HTML5 and newer components.
 
 The body contains the actual content of the page. Everything that is contained in the body is visible to the user.
 
-```html linenums="1"
+```html
 <body>
     <!-- page contents -->
 </body>
@@ -147,7 +147,7 @@ Before using build-in validation make sure that it's supported by the target bro
 
 ## General structure of HTML page
 
-```html linenums="1"
+```html
 <!-- HTML Boilerplate -->
 <!DOCTYPE html>
 <html lang="en">
@@ -189,7 +189,7 @@ Attributes describe additional characteristics of an HTML element.
 
 Paragraphs allow to format the content in a readable fashion.
 
-```html linenums="1"
+```html
 <p> paragraph-content </p>
 <p> paragraph-content </p>
 ```
@@ -198,7 +198,7 @@ Paragraphs allow to format the content in a readable fashion.
 
 Heading numbers indicates hierarchy, not size.
 
-```html linenums="1"
+```html
 <h1> Heading 1 </h1>
 <h2> Heading 2 </h2>
 ```
@@ -225,7 +225,7 @@ Without semantic value, used as last resort:
 
 Surround content to turn into links.
 
-```html linenums="1"
+```html
 <!-- Link to absolute URL -->
 <a href="uri/url" title="content-title" target="_self"> text/image </a>
 
@@ -260,12 +260,12 @@ Surround content to turn into links.
 
 ### Images
 
-```html linenums="1"
+```html
 <img src="image-location" alt="brief-description"/>    <!-- image element -->
 <!-- alt should be always be populated for accessibility and SEO purposes -->
 ```
 
-```html linenums="1"
+```html
 <!-- supported by modern browsers -->
 <figure>
     <img src="img-location" alt="description">
@@ -275,7 +275,7 @@ Surround content to turn into links.
 
 ### Unordered list (bullet list)
 
-```html linenums="1"
+```html
 <ul>
     <li></li>    <!-- list element -->
     <li></li>
@@ -284,7 +284,7 @@ Surround content to turn into links.
 
 ### Ordered list (numbered list)
 
-```html linenums="1"
+```html
 <ol>
     <li></li>
     <li></li>
@@ -293,7 +293,7 @@ Surround content to turn into links.
 
 ### Description list (list of terms and descriptions)
 
-```html linenums="1"
+```html
 <dl>
     <dt>term</dt>    <!-- define term/name -->
     <dd>definition</dd> <!-- describe term/name -->
@@ -304,7 +304,7 @@ Surround content to turn into links.
 
 ### Tables
 
-```html linenums="1"
+```html
 <table>
     <thead>    <!-- table head row -->
         <th></th> <!-- table head, one for each column-->
@@ -332,7 +332,7 @@ Code     | Character
 
 Used to group elements together into sections, eventually to style them differently.
 
-```html linenums="1"
+```html
 <div>
     <!-- content here -->
 </div>
@@ -342,13 +342,13 @@ Used to group elements together into sections, eventually to style them differen
 
 Used to apply a specific style inline.
 
-```html linenums="1"
+```html
 <p> non-styled content <span class="..."> styled content </span> non-styled content </p>
 ```
 
 ### HTML5 new tags
 
-```html linenums="1"
+```html
 <header></header>
 <nav></nav>
 <main></main>
@@ -360,7 +360,7 @@ Used to apply a specific style inline.
 
 ## HTML Forms & Inputs
 
-```html linenums="1"
+```html
 <form action="data-receiver" target="" method="http-method">
     <!-- ALL form elements go here -->
 </form>
@@ -392,7 +392,7 @@ PROs & CONs of `POST` method:
 
 ### Basic Form Elements
 
-```html linenums="1"
+```html
 <form action="" method="">
     <label for="target-identifier">label-here</label>
     <input type="input-type" name="input-name" value="value-sent" id="target-identifier">
@@ -421,7 +421,7 @@ Input Attributes:
 
 One line areas that allow the user to input text.  
 
-```html linenums="1"
+```html
 <input type="text" placeholder="placeholder-text" spellcheck="true" pattern="\regex\">
 ```
 
@@ -429,27 +429,27 @@ One line areas that allow the user to input text.
 
 ### Password Field
 
-```html linenums="1"
+```html
 <input type="password">
 ```
 
 ### Radio Buttons
 
-```html linenums="1"
+```html
 <input type="radio" value="value">
 <input type="radio" value="value" checked>
 ```
 
 ### Checkboxes
 
-```html linenums="1"
+```html
 <input type="checkbox">
 <input type="checkbox" checked>
 ```
 
 ### Dropdown Menus
 
-```html linenums="1"
+```html
 <select multiple>
     <option value="value">Value</option>
     <option value="value">Value</option>
@@ -467,7 +467,7 @@ Conceptually, `<select>` becomes more similar to checkboxes.
 Upload a local file as an attachment. The `accept` attribute value is a string that defines the file types the file input should accept.  
 This string is a comma-separated list of [unique file type specifiers][file_type_specifiers_docs].
 
-```html linenums="1"
+```html
 <input type="file" value="filename" accept=".txt,application/json,audio/*">
 ```
 
@@ -477,13 +477,13 @@ This string is a comma-separated list of [unique file type specifiers][file_type
 
 Multi line text input.
 
-```html linenums="1"
+```html
 <textarea rows="row-number" cols="column-number" >pre-existing editable test</textarea>
 ```
 
 ### Submit & Reset
 
-```html linenums="1"
+```html
 <input type="submit" value="label">
 <input type="reset" value="label">
 <!-- OR -->
@@ -496,7 +496,7 @@ Multi line text input.
 
 ### Button
 
-```html linenums="1"
+```html
 <button type="button/reset/submit" value="label"/>
 
 <!-- can contain HTML -->
@@ -507,7 +507,7 @@ Multi line text input.
 
 Group controls into categories. Particularly important for screen readers.
 
-```html linenums="1"
+```html
 <fieldset>
     <legend>Color</legend>
     <input type="radio" name="colour" value="red" id="colour_red">
@@ -524,7 +524,7 @@ Group controls into categories. Particularly important for screen readers.
 Used to receive a valid e-mail address from the user. Most browsers can validate this without needing javascript.
 Older browsers don't support this input type.
 
-```html linenums="1"
+```html
 <form>
     <label for="user-email">Email:</label>
     <input type="email" name="user-email" id="form-email">
@@ -534,13 +534,13 @@ Older browsers don't support this input type.
 
 ### Progress Bar
 
-```html linenums="1"
+```html
 <progress max="100" value="70"> 70% </progress>
 ```
 
 ### Slider
 
-```html linenums="1"
+```html
 <input type="range" min="0" max="20">
 ```
 
@@ -548,7 +548,7 @@ Older browsers don't support this input type.
 
 The `<meter>` HTML element represents either a scalar value within a known range or a fractional value.
 
-```html linenums="1"
+```html
 <meter min="0" max="100" low="33" high="66" optimum="80" value="50">current value</meter>
 ```
 
@@ -568,7 +568,7 @@ The `datalist` HTML element can provide suggestions to an input that targets it'
 
 ### More Input Types
 
-```html linenums="1"
+```html
 <input type="email" id="email" name="email" />
 <input type="url" id="url" name="url" />
 <input type="number" name="" id="identifier" min="min-value" max="max-value" step="" />

docs/languages/java/dao.md

@@ -4,7 +4,7 @@
 
 Connection to the DB.
 
-```java linenums="1"
+```java
 package dao;
 
 import java.sql.Connection;
@@ -51,7 +51,7 @@ public class DB {
 
 Interface for CRUD methods on a database.
 
-```java linenums="1"
+```java
 package dao;
 
 import java.sql.SQLException;
@@ -69,7 +69,7 @@ public interface I<Type>DAO {
 
 Class implementing `I<Type>DAO` and handling the communication with the db.
 
-```java linenums="1"
+```java
 package dao;
 
 import java.sql.ResultSet;

docs/languages/java/java-collection-framework.md

@@ -18,7 +18,7 @@ The **Java Collection Framework** is constituted by:
 
 ### Collection Functions
 
-```java linenums="1"
+```java
 boolean add (Object o) e.g., <x>.add (<y>)    //append to collection, false if fails
 boolean add (int index, Object o)    //insertion at given index
 boolean addAll (Collection c)    //appends a collection to another
@@ -36,7 +36,7 @@ Iterator iterator()    //returns iterator to iterate over the collection
 
 ### Collections Methods
 
-```java linenums="1"
+```java
 Collection<E>.forEach(Consumer<? super T> action);
 ```
 
@@ -52,7 +52,7 @@ Abstracts the problem of iterating over all the elements of a collection;
 
 **Note**: ArrayLists can't contain *primitive* values. *Use wrapper classes* instead.
 
-```java linenums="1"
+```java
 import java.util.ArrayList;
 ArrayList<Type> ArrayListName = new ArrayList<Type>(starting_dim);    //resizable array
 ArrayList<Type> ArrayListName = new ArrayList<Type>();    //resizable array
@@ -82,7 +82,7 @@ ArrayListName.forEach(item -> function(v));
 
 To sort a collection it's items must implement `Comparable<T>`:
 
-```java linenums="1"
+```java
 class ClassName implements Comparable<ClassName> {
 
     @override
@@ -99,7 +99,7 @@ Collections.sort(list);    //"natural" sorting uses compareTo()
 
 Otherwise a `Comparator()` must be implemented:
 
-```java linenums="1"
+```java
 class Classname {
     //code here
 }

docs/languages/java/java.md

@@ -1,6 +1,6 @@
 # Java
 
-```java linenums="1"
+```java
 //single line comment
 /* multi line comment */
 /** javaDoc docstring */
@@ -19,7 +19,7 @@ Package definition: `package <package_location>;`
 
 ### Main Method (entry point of algorithm)
 
-```java linenums="1"
+```java
 public static void main (String[] args) {
     //code here
 }
@@ -31,21 +31,21 @@ public static void main (String[] args) {
 
 ### Constant Definition (outside of main method/function)
 
-```java linenums="1"
+```java
 public static final Type CONSTANT_NAME = value;
 public static final double PI = 3.14159;   //example
 ```
 
 ### Constant Definition (inside main method/function)
 
-```java linenums="1"
+```java
 final Type CONSTANT_NAME = value;
 final double PI = 3.14159;   //example
 ```
 
 ### Screen Output
 
-```java linenums="1"
+```java
 System.out.println(output_1 + _ + output_n);   //newline at every invocation
 System.out.print(output_1 + _ + output_n);
 ```
@@ -54,7 +54,7 @@ System.out.print(output_1 + _ + output_n);
 
 [String.format() Examples](https://dzone.com/articles/java-string-format-examples)
 
-```java linenums="1"
+```java
 System.out.printf("string %..", variable);
 System.out.println(String.format(format, args));
 ```
@@ -65,7 +65,7 @@ Methods inherited from C. The value pf the variable substitutes %.
 
 `NumberFormat` class is used to format a number output.
 
-```java linenums="1"
+```java
 Locale locale = new Locale("language", "country");  // as defined by IETF lang tag, RCF 5646, RCF 4647
 NumberFormat fmt = NumberFormat.getCurrencyInstance(locale);  // format a number as a currency based on a Locale
 fmt.format(number);  // apply format to a number, returns a String
@@ -73,7 +73,7 @@ fmt.format(number);  // apply format to a number, returns a String
 
 ## Keyboard Input
 
-```java linenums="1"
+```java
 import java.util.Scanner;   //package import
 Scanner scanner = new Scanner(System.in);  //Scanner obj init
 scanner.useDelimiter("delimitatore");   //delimiter setting
@@ -92,7 +92,7 @@ Thus when switching to a different input method is necessary to call `nextLine()
 
 ### Primitive Types
 
-```java linenums="1"
+```java
 TYPE        WRAPPER     SIZE        MIN_VALUE               MAX_VALUE
 int         Integer                 -2147483648             2147483647
 byte        Byte        8 bit       -128                    127
@@ -115,7 +115,7 @@ For high precision calcs is best to use `BigDecimal`.
 
 ### Type Conversion (casting) & Type checking
 
-```java linenums="1"
+```java
 Type variable = (Type) <expression>;  // convert to other Type
 var instanceof Type;  // true if var is an instance of Type
 ```
@@ -125,7 +125,7 @@ var instanceof Type;  // true if var is an instance of Type
 Every primitive type has a corresponding wrapper class.  
 Wrapper classes permits the creation of an object with the same type of a primitive type but with added methods and constants.
 
-```java linenums="1"
+```java
 WrapperClass objectName = new WrapperClass(primitiveValue);  //declaration
 WrapperClass objectName = primitiveValue;  //shortened declaration
 
@@ -143,7 +143,7 @@ WrapperClass.toString(primitive);  // converts the wrapper class value to a stri
 
 ### String & Char
 
-```java linenums="1"
+```java
 String string = "text";  //strings always in double quotes
 char character = 'C';  //chars always in single quotes
 ```
@@ -172,7 +172,7 @@ String are immutable. Concatenation creates a new string.
 
 ### String Conversion to Number
 
-```java linenums="1"
+```java
 double d  = Double.parseDouble(string);
 float f = Float.parseFloat(string);
 int i = integer.parseInt(string);
@@ -180,7 +180,7 @@ int i = integer.parseInt(string);
 
 ### String Class Methods
 
-```java linenums="1"
+```java
 string.equals(otherString);   // returns TRUE if the strings are equal
 string.equalsIgnoreCase(otherString);   // returns TRUE if the strings are equals ignoring the case
 string.charAt(index);  // returns the character at position INDEX
@@ -211,7 +211,7 @@ To compare in alphabetical order both strings must have the same case.
 
 ### Mathematical Operations
 
-```java linenums="1"
+```java
 Math.PI  // value of pi
 Math.E  // value of e
 
@@ -317,7 +317,7 @@ Full evaluation can be forced using `&` and `|`.
 
 ### `If Else`
 
-```java linenums="1"
+```java
 if (condition) {
     //code here
 } else {
@@ -327,7 +327,7 @@ if (condition) {
 
 ### `If, Else If, Else`
 
-```java linenums="1"
+```java
 if (condition) {
     //code here
 } else if (condition) {
@@ -346,7 +346,7 @@ if condition is `true` executes instruction1 otherwise executes instruction2.
 
 ### `Switch`
 
-```java linenums="1"
+```java
 switch (matchExpression) {
     case matchingPattern:
         //code here
@@ -366,7 +366,7 @@ Omitting the `break` keyword causes multiple branches to execute the same code.
 
 ### `While` Loop
 
-```java linenums="1"
+```java
 while (condition) {
    //code here
 }
@@ -374,7 +374,7 @@ while (condition) {
 
 ### `Do While` Loop
 
-```java linenums="1"
+```java
 do {
     //code here
 } while (espressione_booleana);
@@ -384,7 +384,7 @@ Loop body executed *at least* one time
 
 ### `For` Loop
 
-```java linenums="1"
+```java
 for (initializer; condition; iterator) {
     //code here
 }
@@ -392,7 +392,7 @@ for (initializer; condition; iterator) {
 
 ### `Foreach` Loop
 
-```java linenums="1"
+```java
 for (Type variable : iterable){
     //code here
 }
@@ -400,7 +400,7 @@ for (Type variable : iterable){
 
 ### Multiple iterators in `For` Loop
 
-```java linenums="1"
+```java
 for (initializer1, initializer2; condition; iterator1, iterator2) {
     //code here
 }
@@ -417,7 +417,7 @@ The iterator declared in the for is a local variable and can be used only in the
 If the assertion check is enabled (`java -ebableassetrions programName`) the execution of the algorithm is terminated if an assertion fails.  
 Assertions can be used to check if a variable has a wanted value in a precise point in the code (Sanity Check).
 
-```java linenums="1"
+```java
 assert <booleanExpression>;
 ```
 
@@ -427,7 +427,7 @@ Static methods are not bound to an *instance* of a class but they act on the cla
 
 ### Static Void Method Definition
 
-```java linenums="1"
+```java
 static void methodName (parameters) {
     //code here
 }
@@ -435,7 +435,7 @@ static void methodName (parameters) {
 
 ### Static Method Definition
 
-```java linenums="1"
+```java
 static tipo_metodo methodName (parameters) {
     //code here
     return <espressione>;   //returned type MUST match method type
@@ -444,7 +444,7 @@ static tipo_metodo methodName (parameters) {
 
 ### Static Method Invocation
 
-```java linenums="1"
+```java
 methodName(arguments);
 ClassName.methodName(arguments);    //if method is used outside its class
 ```
@@ -453,7 +453,7 @@ ClassName.methodName(arguments);    //if method is used outside its class
 
 ## Array Declaration
 
-```java linenums="1"
+```java
 Type[] arrayName = new Type[dimension];
 
 Type arrayName[] = new Type[dimension];
@@ -463,7 +463,7 @@ arrayName.length  //length of the array
 
 Its possible to break the declaration in two lines  
 
-```java linenums="1"
+```java
 Type[] arrayName;
 arrayType = new Type[dimension];
 ```
@@ -475,7 +475,7 @@ Array dimension is determined by the number of values.
 
 ### Arrays as method parameters
 
-```java linenums="1"
+```java
 static Type methodName (Type[] arrayName) {
     //code here
 }
@@ -492,7 +492,7 @@ Array contents must be confronted by looping through the array.
 
 ### Methods returning Arrays
 
-```java linenums="1"
+```java
 static Type[] methodName (parameters) {
     Type[] arrayName = new Type[dimension];  //array declaration
     //array valorization
@@ -502,7 +502,7 @@ static Type[] methodName (parameters) {
 
 ## Variable numbers of parameters in a method
 
-```java linenums="1"
+```java
 static Type methodName (parameters, tipo[] ArrayName) {
     //code here
 }
@@ -512,14 +512,14 @@ It's not necessary to specify a dimension of the array, it's determined by Java
 
 ### Multi-Dimensional Arrays
 
-```java linenums="1"
+```java
 Type[]...[] arrayName = new Type[dimension1]...[dimensionN];
 Type arrayName[]...[] = new Type[dimension1]...[dimensionN];
 ```
 
 ### Multi-Dimensional Arrays as parameters
 
-```java linenums="1"
+```java
 static Type methodName (Type[]...[] ArrayName) {
     //code here
 }
@@ -527,7 +527,7 @@ static Type methodName (Type[]...[] ArrayName) {
 
 ### Methods returning multi-dimensional arrays
 
-```java linenums="1"
+```java
 static Type[]...[] methodName (parameters) {
     Type[]...[] array = new Type[dimension1]...[dimensionN];
     //array valorization
@@ -537,14 +537,14 @@ static Type[]...[] methodName (parameters) {
 
 ### Array Length of multi-dimensional arrays
 
-```java linenums="1"
+```java
 array.length  //row length
 array[rowIndex].length  //column length
 ```
 
 ### Irregular Table Visualization
 
-```java linenums="1"
+```java
 static void viewTable (Type[][] matrix){
     for (int row = 0; row < matrix.length; row++){   //run through the rows
         for (int column = 0; column < arrayName[row].length; column++){   //run through the columns
@@ -571,7 +571,7 @@ Unchecked exceptions usually mean that there is an error in the logic of the pro
 
 This construct permits to monitor what happens in a block of code and to specify what to do in case of errors (*exceptions*).
 
-```java linenums="1"
+```java
 try {
     //monitored code
 } catch (SpecificException e) {
@@ -590,7 +590,7 @@ A `try-catch` construct can handle multiple exceptions at once.  Every `catch` i
 
 ### Try with Resources
 
-```java linenums="1"
+```java
 try (
     //resource definition
 ){
@@ -607,7 +607,7 @@ try (
 The `throw` keyword is used to generate a custom exception in a point of the code.  
 `throw` is used together with an exception type.
 
-```java linenums="1"
+```java
 Type methodName(parameters) {
     if (condition) {
       throw new Exception("error message");
@@ -618,7 +618,7 @@ Type methodName(parameters) {
 The `throws` keyword is used to indicate what exception Type may be thrown by a method.  
 `throws` is used together with a exception class. It's used to send the exception to the method caller.
 
-```java linenums="1"
+```java
 Type methodName(parameters) throws ExceptionClass {
     if (condition) {
       throw new SpecificException("error message");
@@ -630,7 +630,7 @@ Type methodName(parameters) throws ExceptionClass {
 
 A user-defined exception has to inherit from `Exception` or one of it's descendants.
 
-```java linenums="1"
+```java
 public class CustomException extends Exception {
 
     public CustomException(){
@@ -659,7 +659,7 @@ If not specified variables, methods and classes are *only* accessible from the s
 
 ### Instance Method Definition
 
-```java linenums="1"
+```java
 Type methodName (parameters) {
     //code here
 }
@@ -667,7 +667,7 @@ Type methodName (parameters) {
 
 ### `Void` Instance Method
 
-```java linenums="1"
+```java
 void methodName (parameters) {
     //code here
 }
@@ -675,7 +675,7 @@ void methodName (parameters) {
 
 ### Class Definition
 
-```java linenums="1"
+```java
 public class ClassName {
     //instance variables declaration
 
@@ -711,7 +711,7 @@ Constructors are special methods that are invoked with the `new` operator when a
 Constructors assign the starting values of the object attributes.  
 If a constructor id defined Java doesn't create the default constructor.
 
-```java linenums="1"
+```java
 class ClassName (){
 
     //attributes declaration (aka instance variables)
@@ -736,7 +736,7 @@ Static variable do not belong to the class objects.
 
 ### Getters & Setter Methods
 
-```java linenums="1"
+```java
 public void setAttribute(Type attribute){
     this.attribute = attribute;
 }
@@ -750,7 +750,7 @@ public Type getAttribute(){
 
 Automatically returns a string if the object is directly called in a print method.
 
-```java linenums="1"
+```java
 @Override
 Public String toString(){
     return "string-representation-of-object"
@@ -777,7 +777,7 @@ A child class can inherit from *only* one parent class.
 Child class **must** implement a constructor that instantiates the parent (super) class.  
 `super()` instantiates the superclass of the child class.
 
-```java linenums="1"
+```java
 class ChildClass extends ParentClass{
 
     public ChildClass(parentParameters, childParameters){
@@ -800,7 +800,7 @@ An overridden method can change the access modifier as long as the new modifier
 
 A `ParentClass` type can contain a `ChildClass` object. This is useful for using collections and arrays of objects.
 
-```java linenums="1"
+```java
 ParentClass objectName = ChildClass();  // upcast
 (ChildClass)ParentClassObject;  // downcast
 ```
@@ -814,7 +814,7 @@ Abstract classes are marked by the `abstract` keyword.
 An abstract method is a method without implementation.  
 The methods **must** be `public` and marked with the `abstract` keyword.
 
-```java linenums="1"
+```java
 //abstract class
 abstract class className{
     //attributes here
@@ -838,7 +838,7 @@ Interfaces' attributes are always `public static final`, no need for the keyword
 
 A class can implement *more than one* Interface.
 
-```java linenums="1"
+```java
 public interface InterfaceName{
     //attributes here
 
@@ -869,7 +869,7 @@ Enums are used to restrict the type of data to a set of the possible constant va
 Enums are classes which constructor is private by default.
 It's still possible to create a custom constructor to add values.
 
-```java linenums="1"
+```java
 enum enumName {
     value1,
     value2,
@@ -904,7 +904,7 @@ enumName variable;  //creation of a variable of type enumName
 
 *Anonymous classes* make the code more concise. They enable to declare and instantiate a class at the same time. They are like local classes except that they do not have a name. Useful if is needed a local class that is used once.
 
-```java linenums="1"
+```java
 AnonymousClass objectName = new AnonymousClass(Type parameter, ...) {
 
     // attributes
@@ -915,7 +915,7 @@ AnonymousClass objectName = new AnonymousClass(Type parameter, ...) {
 
 ### Cloning
 
-```java linenums="1"
+```java
 class ClassName implements Clonable {
 
 }
@@ -923,7 +923,7 @@ class ClassName implements Clonable {
 
 ## Generics
 
-```java linenums="1"
+```java
 // WARNING: T is not instantiable, new t(), new t[] are INVALID
 public class GenericClass<T> {
     private T generic;
@@ -949,7 +949,7 @@ GenericClass<Type>[] obj = new GenericClass<>[];  // invalid
 
 ### Multiple Generics
 
-```java linenums="1"
+```java
 public class GenericClass<T1, T2, ...> { }  // number of generic types is not limited
 ```
 
@@ -957,7 +957,7 @@ public class GenericClass<T1, T2, ...> { }  // number of generic types is not li
 
 Specify an interface or class that the generic type must implement/inherit.
 
-```java linenums="1"
+```java
 public class GenericClass<T extends Interface1 & Interface2> { }
 public class GenericClass<T1 extends Interface1 & Interface2, T2 extends Class1> { }
 public class GenericClass<T extends Class1> { }
@@ -965,7 +965,7 @@ public class GenericClass<T extends Class1> { }
 
 ### Generic Methods
 
-```java linenums="1"
+```java
 public class ClassName{
 
     public <T> methodName() {
@@ -1001,7 +1001,7 @@ obj.<Type>methodName();  // generic method call
 
 #### Writing on a file
 
-```java linenums="1"
+```java
 // opening/creating the file for writing
 PrintWriter outStream = null;  // output stream creation
 try{
@@ -1022,7 +1022,7 @@ outStream.close()  // close stream and write buffer contents.
 
 #### Reading from a file
 
-```java linenums="1"
+```java
 Filereader filereader = new Filereader("filename");  //open the file
 Scanner scanner = new Scanner(filereader);  //scanner for the file
 
@@ -1058,7 +1058,7 @@ public void close() throws IOException  // closes the stream
 
 The File class is an abstraction of the file and it's path. The abstraction is independent from the OS.
 
-```java linenums="1"
+```java
 File("path/to/file")  // UNIX like path
 File("path\\to\\file")  // Windows path
 
@@ -1075,7 +1075,7 @@ file.length()  // file length in bytes
 
 #### Writing to a binary file
 
-```java linenums="1"
+```java
 ObjectOutputStream outStream;
 try {
     outStream = new ObjectOutputStream(new FileOutputSteam(filename));
@@ -1104,7 +1104,7 @@ public void close()
 
 #### Reading from a binary file
 
-```java linenums="1"
+```java
 ObjectInputStream inStream;
 try {
     inStream = new ObjectInputStream(new FileinputSteam(filename));
@@ -1148,7 +1148,7 @@ Needed for a class to be *serializable*:
 
 An array is serializable if it's base type is a serializable object.
 
-```java linenums="1"
+```java
 SerializableObject[] array = (SerializableObject[])inStream.readObject();  // read returns Object, cast needed
 ```
 
@@ -1160,7 +1160,7 @@ Functional interfaces provide target types for *lambda expressions*.
 
 General purpose `@functionalInterfaces`:
 
-```java linenums="1"
+```java
 // takes input, performs actions, return boolean
 public interface Predicate<T> {
     boolean test(T t);
@@ -1215,7 +1215,7 @@ The features of Java stream are:
 
 Usable only by a `@FunctionalInterface`'s method or a method of a *stream*.
 
-```java linenums="1"
+```java
 lambda operator -> body;
 
 //zero parameter

docs/languages/java/spring/pom.xml.md

@@ -2,7 +2,7 @@
 
 File specifing project dependencies.
 
-```xml linenums="1"
+```xml
 <?xml version="1.0" encoding="UTF-8"?>
 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">

docs/languages/java/spring/spring-project.md

@@ -10,7 +10,7 @@
 
 ## application.properties
 
-```ini linenums="1"
+```ini
 spring.datasource.url=DB_url
 spring.datasource.username=user
 spring.datasource.password=password
@@ -24,7 +24,7 @@ server.port=server_port
 
 Model of a table of the DB
 
-```java linenums="1"
+```java
 package <base_package>.entities;
 
 import javax.persistence.Entity;
@@ -54,7 +54,7 @@ public class Entity {
 
 Spring Interface for DB connection and CRUD operations.
 
-```java linenums="1"
+```java
 package <base_package>.dal  // or .repository
 
 import org.springframework.data.repository.JpaRepository;
@@ -77,7 +77,7 @@ Interfaces and method to access the Data Access Layer (DAL).
 
 In `IEntityService.java`:
 
-```java linenums="1"
+```java
 package <base_package>.services;
 
 import java.util.List;
@@ -105,7 +105,7 @@ public interface IEntityService {
 
 In `EntityService.java`:
 
-```java linenums="1"
+```java
 package <base_package>.services;
 
 import java.util.List;
@@ -161,7 +161,7 @@ public class EntityService implements IEntityService {
 
 REST API routes & endpoints to supply data as JSON.
 
-```java linenums="1"
+```java
 package <base_package>.integration;
 
 import java.util.List;

docs/languages/java/web/servlet.md

@@ -5,7 +5,7 @@ Although servlets can respond to many types of requests, they most commonly impl
 
 ## Basic Structure
 
-```java linenums="1"
+```java
 package <package>;
 
 import java.io.IOException;
@@ -39,7 +39,7 @@ public class <className> extends HttpServlet {
 
 ## Servlet Instructions
 
-```java linenums="1"
+```java
 request.getParameter()  // read request parameter
 
 response.setContentType("text/html");  // to return HTML in the response

docs/languages/javascript/ajax.md

@@ -14,7 +14,7 @@ AJAX Interaction:
 
 ## XMLHttpRequest
 
-```js linenums="1"
+```js
 var request = new XMLHttpRequest();
 
 request.addEventListener(event, function() {...});
@@ -39,7 +39,7 @@ To check the status use `XMLHttpRequest.status` and `XMLHttpRequest.statusText`.
 
 **Alternative `XMLHttpRequest` using `onLoad`**:
 
-```js linenums="1"
+```js
 var request = new XMLHttpRequest();
 request.open('GET', 'myservice/username?id=some-unique-id');
 request.onload = function(){
@@ -54,7 +54,7 @@ request.send();
 
 **Alternative `XMLHttpRequest` using `readyState`**:
 
-```js linenums="1"
+```js
 var request = new XMLHttpRequest(),  method ='GET',  url ='https://developer.mozilla.org/';
 
 request.open(method, url, true);
@@ -77,7 +77,7 @@ request.send();
 
 Old versions of IE don't implement XMLHttpRequest. You must use the ActiveXObject if XMLHttpRequest is not available
 
-```js linenums="1"
+```js
 var request =window.XMLHttpRequest ? new XMLHttpRequest() : new ActiveXObject('Microsoft.XMLHTTP');
 
 // OR

docs/languages/javascript/dom.md

@@ -10,7 +10,7 @@ The document object is *globally available* in the browser. It allows to access
 `getElementById()` and `querySelector()` return a single element.  
 `getElementsByClassName()`, `getElementsByTagName()`, and `querySelectorAll()` return a collection of elements.
 
-```js linenums="1"
+```js
 Javascript
 // By Id
 var node = document.getElementById('id');
@@ -32,7 +32,7 @@ var nodes = document.querySelectorAll('css-selector');
 
 It's possible access and change the attributes of a DOM node using the *dot notation*.
 
-```js linenums="1"
+```js
 // Changing the src of an image:
 var image = document.getElementById('id');
 var oldImageSource = image.src;
@@ -48,7 +48,7 @@ node.className = 'new-class';
 It's possible to access and change the styles of a DOM nodes via the **style** property.
 CSS property names with a `-` must be **camelCased** and number properties must have a unit.
 
-```css linenums="1"
+```css
 body {
     color: red;
     background-color: pink;
@@ -56,7 +56,7 @@ body {
 }
 ```
 
-```js linenums="1"
+```js
 var pageNode = document.body;
 pageNode.style.color = 'red';
 pageNode.style.backgroundColor = 'pink';
@@ -67,7 +67,7 @@ pageNode.style.paddingTop = '10px';
 
 Each DOM node has an `innerHTML` attribute. It contains the HTML of all its children.
 
-```js linenums="1"
+```js
 var pageNode = document.body;
 console.log(pageNode.innerHTML);
 
@@ -96,13 +96,13 @@ To change the actual text of a node, `textContent` may be a better choice:
 
 In `page.html`:
 
-```html linenums="1"
+```html
 <input type="" id="identifier" value="">
 ```
 
 In `script.js`:
 
-```js linenums="1"
+```js
 var formNode = document.getElementById("Identifier");
 var value = formNode.value;
 ```
@@ -111,7 +111,7 @@ var value = formNode.value;
 
 The document object also allows to create new nodes from scratch.
 
-```js linenums="1"
+```js
 // create node
 document.createElement('tagName');
 document.createTextNode('text');
@@ -129,7 +129,7 @@ node.parentNode.removeChild(node);
 
 Example:
 
-```js linenums="1"
+```js
 var body = document.body;
 
 var newImg = document.createElement('img');
@@ -148,7 +148,7 @@ body.appendChild(newParagraph);
 
 ### Creating DOM Nodes with Constructor Functions
 
-```js linenums="1"
+```js
 function Node(params) {
     this.node = document.createElement("tag");
 

docs/languages/javascript/events-animation.md

@@ -12,7 +12,7 @@ Event Types:
 
 ### Managing Event Listeners
 
-```js linenums="1"
+```js
 var domNode = document.getElementById("id");
 
 var onEvent = function(event) {  // parameter contains info on the triggered event
@@ -38,7 +38,7 @@ Event Options:
 - `bubbles` (bool): whether the event propagates through bubbling
 - `cancellable` (bool): if `true` the "default action" may be prevented
 
-```js linenums="1"
+```js
 let event = new Event(type [,options]);  // create the event, type can be custom
 let event = new CustomEvent(type, { detail: /* custom data */ });  // create event w/ custom data
 domNode.dispatchEvent(event);  // launch the event
@@ -53,7 +53,7 @@ The window object is the assumed global object on a page.
 Animation in JavascriptThe standard way to animate in JS is to use window methods.
 It's possible to animate CSS styles to change size, transparency, position, color, etc.
 
-```js linenums="1"
+```js
 //Calls a function once after a delay
 window.setTimeout(callbackFunction, delayMilliseconds);
 
@@ -73,7 +73,7 @@ window.requestAnimationFrame(callbackFunction);
 [StackOverflow](https://stackoverflow.com/a/294273/8319610)
 [Wrong dimensions at runtime](https://stackoverflow.com/a/46772849/8319610)
 
-```js linenums="1"
+```js
 > console.log(document.getElementById('id').getBoundingClientRect());
 DOMRect {
     bottom: 177,

docs/languages/javascript/javascript.md

@@ -11,14 +11,14 @@
 
 ### Comments
 
-```javascript linenums="1"
+```javascript
 //single line comment
 /*multiline comment*/
 ```
 
 ### File Header
 
-```javascript linenums="1"
+```javascript
 /**
  * @file filename.js
  * @author author's name
@@ -32,7 +32,7 @@
 
 If located at the top of the script the whole script works the “modern” way (enables post-ES5 functionalities).  
 
-```js linenums="1"
+```js
 "use strict"
 
 // script contents
@@ -42,7 +42,7 @@ If located at the top of the script the whole script works the “modern” way
 
 Interrupts script execution until closure, **to be avoided**
 
-```javascript linenums="1"
+```javascript
 alert("message");
 ```
 
@@ -69,7 +69,7 @@ Variable names can only contain numbers, digits, underscores and $. Variable nam
 Variable declared with `let` are in local to the code block in which are declared.
 Variable declared with `var` are local only if declared in a function.
 
-```js linenums="1"
+```js
 function func(){
     variable = value;  // implicitly declared as a global variable
     var variable = value;  // local variable
@@ -99,7 +99,7 @@ Hard-coded values are UPPERCASE and snake_case, camelCase otherwise.
 
 Only numeric type is `number`.
 
-```javascript linenums="1"
+```javascript
 let number = 10;  //integer numbers
 number = 15.7;  //floating point numbers
 number = Infinity;  //mathematical infinity
@@ -115,7 +115,7 @@ Mathematical expression will *never* cause an error. At worst the result will be
 
 ### String data type
 
-```javascript linenums="1"
+```javascript
 let string = "text";
 let string$ = 'text';
 let string_ = `text ${expression}`;  //string interpolation (needs backticks)
@@ -137,7 +137,7 @@ Property access is unpredictable:
 
 If the parameters to slice are negative, they reference the string from the end. Substring and substr doesn´t.
 
-```js linenums="1"
+```js
 string.slice(begin [, end]);
 string.substring(from [, to]);
 string.substr(start [, length]);
@@ -145,27 +145,27 @@ string.substr(start [, length]);
 
 ### Boolean data type
 
-```javascript linenums="1"
+```javascript
 let boolean = true;
 let boolean_ = false;
 ```
 
 ### Null data type
 
-```javascript linenums="1"
+```javascript
 let _ = null;
 ```
 
 ### Undefined
 
-```javascript linenums="1"
+```javascript
 let $;  //value is "undefined"
 $ = undefined;
 ```
 
 ### Typeof()
 
-```javascript linenums="1"
+```javascript
 typeof x;  //returns the type of the variable x as a string
 typeof(x);  //returns the type of the variable x as a string
 ```
@@ -176,7 +176,7 @@ It is a special value with a separate type of its own. So, again, this is an err
 
 ### Type Casting
 
-```javascript linenums="1"
+```javascript
 String(value);  //converts value to string
 
 Number(value);  //converts value to a number
@@ -200,7 +200,7 @@ typeof var_ == "number";  // typeof returns a string with the name of the type
 
 ### Type Checking
 
-```js linenums="1"
+```js
 isNaN(var);  // converts var in number and then check if is NaN
 
 Number("A") == NaN;  //false ?!?
@@ -209,7 +209,7 @@ Number("A") == NaN;  //false ?!?
 
 ### Dangerous & Stupid Implicit Type Casting
 
-```js linenums="1"
+```js
 2 + 'text';  //"2text", implicit conversion and concatenation
 1 + "1";  //"11", implicit conversion and concatenation
 "1" + 1;  //"11", implicit conversion and concatenation
@@ -305,7 +305,7 @@ Number("A") == NaN;  //false ?!?
 
 ### IF-ELSE
 
-```javascript linenums="1"
+```javascript
 if (condition) {
     //code here
 } else {
@@ -315,7 +315,7 @@ if (condition) {
 
 ### IF-ELSE Multi-Branch
 
-```javascript linenums="1"
+```javascript
 if (condition) {
     //code here
 } else if (condition) {
@@ -331,7 +331,7 @@ if (condition) {
 
 ### Switch Statement
 
-```javascript linenums="1"
+```javascript
 switch (expression) {
     case expression:
         //code here
@@ -347,7 +347,7 @@ switch (expression) {
 
 ### While Loop
 
-```javascript linenums="1"
+```javascript
 while (condition) {
     //code here
 }
@@ -355,7 +355,7 @@ while (condition) {
 
 ### Do-While Loop
 
-```javascript linenums="1"
+```javascript
 do {
     //code here
 } while (condition);
@@ -363,7 +363,7 @@ do {
 
 ### For Loop
 
-```javascript linenums="1"
+```javascript
 // basic for
 for (begin; condition; step) { }
 
@@ -384,7 +384,7 @@ iterable.forEach(() => { /* statements */ });
 `break;`  exits the loop.  
 `continue;` skip to next loop cycle.
 
-```javascript linenums="1"
+```javascript
 label: for(begin; condition; step) {
     //code here
 }
@@ -394,7 +394,7 @@ break label;  //breaks labelled loop and nested loops inside it
 
 ## Arrays
 
-```js linenums="1"
+```js
 let array = [];  // empty array
 let array = ["text", 3.14, [1.41]];  // array declaration and initialization
 
@@ -417,7 +417,7 @@ array.splice(start, deleteCount, [items_to_add]);  // remove and RETURN items fr
 
 ### `filter()` & `map()`, `reduce()`
 
-```js linenums="1"
+```js
 let array = [ items ];
 
 // execute an operation on each item, producing a new array
@@ -432,7 +432,7 @@ array.reduce((x, y) => ...);
 
 ## Spread Operator (...)
 
-```js linenums="1"
+```js
 // arrays
 let array1 = [ 1, 2, 3, 4, 5, 6 ];
 let array2 = [ 7, 8, 9, 10 ];
@@ -457,7 +457,7 @@ func(arg0, ...args);
 
 ## Dictionaries
 
-```js linenums="1"
+```js
 let dict = { FirstName: "Chris", "one": 1, 1: "some value" };
 
 
@@ -471,7 +471,7 @@ dict.FirstName = "Chris";
 
 ### Iterating Key-Value pairs
 
-```js linenums="1"
+```js
 for(let key in dict) {
   let value = dict[key];
 
@@ -485,7 +485,7 @@ Object.keys(dict).forEach(key => { });
 
 ### JSDOC documentation standard
 
-```javascript linenums="1"
+```javascript
 /**
  * @param {type} parameter - description
  * @returns {type} parameter - description
@@ -494,7 +494,7 @@ Object.keys(dict).forEach(key => { });
 
 ### Function Declaration
 
-```javascript linenums="1"
+```javascript
 // ...args will contain extra parameters (rest argument)
 function functionName(parameter=default-value, ...args) {
     //code here
@@ -504,7 +504,7 @@ function functionName(parameter=default-value, ...args) {
 
 ### Default Parameters (old versions)
 
-```javascript linenums="1"
+```javascript
 function functionName(parameters) {
     if (parameter == undefined) {
         parameter = value;
@@ -517,7 +517,7 @@ function functionName(parameters) {
 
 ### Function Expressions
 
-```javascript linenums="1"
+```javascript
 let functionName = function(parameters) {
     //code here
     return expression;
@@ -526,7 +526,7 @@ let functionName = function(parameters) {
 
 ### Arrow Functions
 
-```javascript linenums="1"
+```javascript
 (input) => { /* statements */ }
 (input) => expression;
 input => expression;  // parenthesis are optional
@@ -552,7 +552,7 @@ An object is a collection of related data and/or functionality.
 
 **Note**: It's not possible to transform a variable in an object simply by using the object assignment.
 
-```js linenums="1"
+```js
 let variable = value;
 
 // object literal
@@ -596,7 +596,7 @@ Object.entries(obj);  // list contents as key-value pairs
 JavaScript uses special functions called **constructor functions** to define and initialize objects and their features.
 Notice that it has all the features you'd expect in a function, although it doesn't return anything or explicitly create an object — it basically just defines properties and methods.
 
-```js linenums="1"
+```js
 // constructor function definition
 function Class(params) {
     this.property = param;
@@ -622,7 +622,7 @@ An object's prototype object may also have a prototype object, which it inherits
 This is often referred to as a **prototype chain**, and explains why different objects have properties and methods defined on other objects available to them.
 If a method is implemented on an object (and not it's prototype) then only that object will heve that method and not all the ones that come from the same prototype.
 
-```js linenums="1"
+```js
 // constructor function
 function Obj(param1, ...) {
     this.param1 = param1,
@@ -640,7 +640,7 @@ obj.method();  // call method from prototype
 
 ### Extending with prototypes
 
-```js linenums="1"
+```js
 // constructor function
 function DerivedObj(param1, param2, ...) {
     Obj.call(this, param1);  // use prototype constructor
@@ -661,7 +661,7 @@ dobj.method();  // call method from prototype
 
 ### Classes (ES6+)
 
-```js linenums="1"
+```js
 class Obj {
     constructor(param1, ...) {
         this.param1 = param1,
@@ -686,7 +686,7 @@ obj.func();  // call method
 
 ### Extending with Classes
 
-```js linenums="1"
+```js
 class DerivedObj extends Obj {
     constructor(param1, param2, ...){
         super(param1);  // use superclass constructor
@@ -704,7 +704,7 @@ dobj.newFunc();
 
 ### Object deconstruction
 
-```js linenums="1"
+```js
 let obj = {
     property: value,
     ...
@@ -717,14 +717,14 @@ let { property: var1, var2 = default_value } = obj;  // use default values if ob
 
 ### Array Deconstruction
 
-```js linenums="1"
+```js
 let array = [ 1, 2, 3, 4, 5, 6 ];
 let [first, , third, , seventh = "missing" ] = array;  // extract specific values from array
 ```
 
 ## Serialization
 
-```js linenums="1"
+```js
 let object = {
     // object attributes
 }
@@ -741,7 +741,7 @@ let object = JSON.parse(json);  // deserialize to Object
 
 Function runs *once* after an interval of time.
 
-```js linenums="1"
+```js
 // param1, param2, ... are the arguments passed to the function (IE9+)
 let timerId = setTimeout(func [, milliseconds, param1, param2, ... ]);  // wait milliseconds before executing the code (params are read at execution time)
 
@@ -776,7 +776,7 @@ useTimeout();
 
 ### `let` vs `var` with `setTimeout`
 
-```js linenums="1"
+```js
 // let instantiates a new variable for each iteration
 for (let i = 0; i < 3; ++i) {
     setTimeout(function() {
@@ -795,7 +795,7 @@ for (var i = 0; i < 3; ++i) {
 
 ### Preserving the context
 
-```js linenums="1"
+```js
 let obj = {
     prop: value,
 
@@ -824,7 +824,7 @@ let obj = {
 
 Function runs regularly with a specified interval. JavaScript is **Single Threaded**.
 
-```js linenums="1"
+```js
 // param1, param2, ... are the arguments passed to the function (IE9+)
 let timerId = setInterval(func, milliseconds [, param1, param2, ... ]); // (params are read at execution time)
 
@@ -852,7 +852,7 @@ There are generally 4 types of JavaScript date input formats:
 - Long Date: `"Mar 25 2015"` or `"25 Mar 2015"`
 - Full Date: `"Wednesday March 25 2015"`
 
-```js linenums="1"
+```js
 // constructors
 new Date();
 new Date(milliseconds);
@@ -892,7 +892,7 @@ let date = new Date(msec);
 
 Comparison operators work also on dates
 
-```js linenums="1"
+```js
 let date1 = new Date();
 let date2 = new Date("May 24, 2017 10:50:00");
 
@@ -909,20 +909,20 @@ if(date1 > date2){
 
 > **Note**: Firefox 68 and later define the origin of a page opened using a `file:///` URI as unique. Therefore, other resources in the same directory or its subdirectories no longer satisfy the CORS same-origin rule. This new behavior is enabled by default using the `privacy.file_unique_origin` preference.
 
-```json linenums="1"
+```json
 "privacy.file_unique_origin": "false"
 ```
 
 In `page.html`
 
-```html linenums="1"
+```html
 <script src="scripts/module.js"></script>
 <script src="scripts/script.js"></script>
 ```
 
 In `module.js`:
 
-```js linenums="1"
+```js
 // exporting individual fractures
 export default function() {}  // one per module
 export func = () => expression;  // zero or more per module
@@ -942,7 +942,7 @@ export { func } from "other_script.js"
 
 In `script.js`:
 
-```js linenums="1"
+```js
 import default_func_alias, { func as alias } from "./module.js";  // import default and set alias
 import { default as default_func_alias, func as alias } from "./module.js";  // import default and set alias
 
@@ -951,7 +951,7 @@ default_func_alias();
 alias();
 ```
 
-```js linenums="1"
+```js
 import * from "./module.js";  // import all
 
 module.function();  // use imported content with fully qualified name

docs/languages/javascript/jquery.md

@@ -4,7 +4,7 @@
 
 ### Download and link the file
 
-```html linenums="1"
+```html
 <head>
     <script src="jquery-x.x.x.min.js"></script>
 </head>
@@ -12,7 +12,7 @@
 
 ### Use a CDN
 
-```html linenums="1"
+```html
 <head>
     <script src="https://ajax.googleapis.com/ajax/libs/jquery/x.x.x/jquery.min.js"></script>
 </head>
@@ -34,7 +34,7 @@ CDNs serve a large fraction of the Internet content today, including web objects
 
 ### [Finding DOM elements](https://api.jquery.com/category/selectors/)
 
-```js linenums="1"
+```js
 $('tag');
 $("#id");
 $(".class");
@@ -42,11 +42,11 @@ $(".class");
 
 ### Manipulating DOM elements
 
-```js linenums="1"
+```js
 $("p").addClass("special");
 ```
 
-```html linenums="1"
+```html
 <!-- before -->
 <p>Welcome to jQuery<p>
 
@@ -56,11 +56,11 @@ $("p").addClass("special");
 
 ### Reading Elements
 
-```html linenums="1"
+```html
 <a id="yahoo" href="http://www.yahoo.com" style="font-size:20px;">Yahoo!</a>
 ```
 
-```js linenums="1"
+```js
 // find it & store it
 var link = $('a#yahoo');
 
@@ -72,14 +72,14 @@ link.css('font-size'); // '20px
 
 ### Modifying Elements
 
-```js linenums="1"
+```js
 // jQuery
 $('a').html('Yahoo!');
 $('a').attr('href', 'http://www.yahoo.com');
 $('a').css({'color': 'purple'});
 ```
 
-```html linenums="1"
+```html
 <!-- before -->
 <a href="http://www.google.com">Google</a>
 
@@ -89,7 +89,7 @@ $('a').css({'color': 'purple'});
 
 ### Create, Store, Manipulate and inject
 
-```js linenums="1"
+```js
 let paragraph = $('<p class="intro">Welcome<p>');  // create and store element
 
 paragraph.css('property', 'value');  // manipulate element
@@ -99,7 +99,7 @@ $("body").append(paragraph);  // inject in DOM
 
 ### Regular DOM Nodes to jQuery Objects
 
-```js linenums="1"
+```js
 var paragraphs = $('p'); // an array
 var aParagraph = paragraphs[0]; // a regular DOM node
 var $aParagraph = $(paragraphs[0]); // a jQuery Object
@@ -114,7 +114,7 @@ for(var i = 0; i < paragraphs.length; i++) {
 
 ## [Events](https://api.jquery.com/category/events/)
 
-```js linenums="1"
+```js
 var onButtonClick = function() {  
     console.log('clicked!');
 }
@@ -133,7 +133,7 @@ $('button').click(onButtonClick);
 
 ### Preventing Default Event
 
-```js linenums="1"
+```js
 $('selector').on('event', function(event) {
     event.preventDefault();
     // custom logic
@@ -144,13 +144,13 @@ $('selector').on('event', function(event) {
 
 In the HTML, add a `<script>` ag that hotlinks to the CDN or source file:
 
-```html linenums="1"
+```html
 <script src="https://cdnjs.cloudflare.com/ajax/libs/jquery-validate/1.17.0/jquery.validate.min.js"><script>
 ```
 
 In the JavaScript call the jQuery plugin on the DOM:
 
-```js linenums="1"
+```js
 $("form").validate();
 ```
 
@@ -160,7 +160,7 @@ $("form").validate();
 
 ### Patters & Anti-Patterns
 
-```js linenums="1"
+```js
 // Pattern: name variables with $var
 $myVar =$('#myNode');
 
@@ -179,7 +179,7 @@ $(document).on('click', 'p', function(argument){
 
 ### Chaining
 
-```js linenums="1"
+```js
 banner.css('color', 'red');
 banner.html('Welcome!');
 banner.show();
@@ -197,7 +197,7 @@ banner.css('color', 'red')
 
 DOM manipulation and event binding doesn't work if the `<script>` is in the `<head>`
 
-```js linenums="1"
+```js
 $(document).ready(function() {
     // the DOM is fully loaded
 });
@@ -209,7 +209,7 @@ $(window).on('load', function(){
 
 ## AJAX (jQuery `1.5`+)
 
-```js linenums="1"
+```js
 $.ajax({
     method: 'POST',
     url: 'some.php',

docs/languages/javascript/react/react-router.md

@@ -16,7 +16,7 @@ Router Types:
 - *BrowserRouter*: `/route`, uses HTML5 history API to provide clean URLs
 - *MemoryRouter*: no URL
 
-```js linenums="1"
+```js
 // index.js
 
 //other imports ...
@@ -31,7 +31,7 @@ React.render(
 )
 ```
 
-```js linenums="1"
+```js
 // Component.js
 import { Route, Route } from "react-router-dom";
 
@@ -52,7 +52,7 @@ import { Route, Route } from "react-router-dom";
 
 ### URL Parameters & Query String
 
-```js linenums="1"
+```js
 // Given
 <Route path="/route/:placeholder" element={<Component props={props} />} />
 // URL: app.com/route/sub-route?param=value
@@ -66,7 +66,7 @@ function Component(props) {
 
 ### Redirecting
 
-```js linenums="1"
+```js
 import { Navigate } from "react-router-dom";
 
 // redirects to another URL on render, shouldn't be rendered on component mount but after an action
@@ -80,7 +80,7 @@ props.history.push("/new-route");
 
 ### Prompts
 
-```js linenums="1"
+```js
 import { Prompt } from "react-router-dom";
 
 // displays a prompt when the condition is true
@@ -91,7 +91,7 @@ import { Prompt } from "react-router-dom";
 
 Clicks on a link created with React-Router will be captured by react an all the routing will happen client side.
 
-```js linenums="1"
+```js
 import { Link } from "react-router-dom";
 
 // TARGET: <Route path="/route/:itemId" />

docs/languages/javascript/react/react-tests.md

@@ -4,7 +4,7 @@
 
 ### Jest Configuration
 
-```js linenums="1"
+```js
 // jest.config.js
 module.exports = {
   testEnvironment: 'jsdom',
@@ -18,7 +18,7 @@ module.exports = {
 
 [Expect docs](https://jestjs.io/docs/expect)
 
-```js linenums="1"
+```js
 // .spec.js or .test.js
 it("test description", () => {
     // test body
@@ -36,7 +36,7 @@ describe("test group name", () => {
 
 In `Component.Snapshots.js`:
 
-```js linenums="1"
+```js
 import React from "react";
 import renderer from "react-test-renderer";
 
@@ -60,7 +60,7 @@ it("test description", () => {
 
 ### Enzyme Configuration
 
-```js linenums="1"
+```js
 // testSetup.js
 import { configure } from "enzyme";
 import Adapter from "enzyme-adapter-react-<version>";
@@ -72,7 +72,7 @@ configure({ adapter: new Adapter() });
 
 In `Component.test.js`:
 
-```js linenums="1"
+```js
 import React from "react";
 import { shallow, mount } from "enzyme";
 // eventual wrapper components (react-router, react-redux's provider, ...) for mount render
@@ -125,7 +125,7 @@ Encourages to write test based on what the user sees. So components are always *
 
 In `Components.test.js`:
 
-```js linenums="1"
+```js
 import React from "react";
 import { cleanup, render } from "@testing-library/react";
 

docs/languages/javascript/react/react.md

@@ -9,7 +9,7 @@ There are two types of react components:
 
 Both types can be stateful and have side effects or be purely presentational.
 
-```jsx linenums="1"
+```jsx
 // functional component
 const Component = (props) => {
     return (
@@ -33,7 +33,7 @@ Within the component state can be changed while the props object represent fixed
 
 JSX syntax can represent HTML but gets converted to pure JavaScript before being sent to the browser:
 
-```js linenums="1"
+```js
 // JSX
 const element = (
   <h1 className="greeting">Hello, world!</h1>
@@ -49,7 +49,7 @@ const element = React.createElement(
 
 ### App Entry-point
 
-```js linenums="1"
+```js
 const container = document.getElementById('root')!;
 const root = createRoot(container);
 
@@ -59,7 +59,7 @@ root.render(element)
 
 ### Dynamic Expressions
 
-```js linenums="1"
+```js
 <tag>{expression}</tag>  // expression is evaluated an it's result is displayed
 <tag onEvent={funcReference}>{expression}</tag>
 <tag onEvent={() => func(args)}>{expression}</tag>
@@ -67,7 +67,7 @@ root.render(element)
 
 ### Props
 
-```js linenums="1"
+```js
 <Component propName={value} />  // pass a value the component
 <Component propName={funcReference} />  // pass a function to the component
 
@@ -83,7 +83,7 @@ class Component extends React.Component{
 
 ### Simple Function Component
 
-```js linenums="1"
+```js
 // Button.js
 import { useState } from "react";
 
@@ -105,7 +105,7 @@ export default Button;
 
 ### Simple Class Component
 
-```js linenums="1"
+```js
 class Button extends React.Component {
 
     state = {count: 0};
@@ -137,7 +137,7 @@ class Button extends React.Component {
 
 ### Nesting Components
 
-```js linenums="1"
+```js
 import { useState } from "react";
 
 function Button(props) {
@@ -173,7 +173,7 @@ export default App;
 
 ### User Input (Forms)
 
-```js linenums="1"
+```js
 function Form() {
     const [userName, setUserName] = useState("");
 
@@ -198,7 +198,7 @@ function Form() {
 
 ### Lists of Components
 
-```js linenums="1"
+```js
 // ...
     <div>
         {array.map(item => <Component key={uniqueID}>)}
@@ -219,7 +219,7 @@ Hook used to create a state object.
 - state object (getter)
 - updater function (setter)
 
-```js linenums="1"
+```js
 const [state, setState] = useState(default);
 ```
 
@@ -227,7 +227,7 @@ const [state, setState] = useState(default);
 
 Hook used to trigger an action on each render of the component or when one of the watched items changes.
 
-```js linenums="1"
+```js
 
 useEffect(() => {
     // "side effects" operations
@@ -238,7 +238,7 @@ useEffect(() => {
 
 ### Custom Hooks
 
-```js linenums="1"
+```js
 // hook definitions
 const useCustomHook = () => {
     // eventual state definitions

docs/languages/javascript/react/redux-tests.md

@@ -9,7 +9,7 @@ Connected components are wrapped in a call to `connect`. Way of solving the prob
 
 In `Component.js`:
 
-```js linenums="1"
+```js
 export function Component(props) { /* ... */ }  // export unconnected component
 
 export default connect(mapStateToProps, mapDispatchToProps)(Component)  // default export of connected component
@@ -17,7 +17,7 @@ export default connect(mapStateToProps, mapDispatchToProps)(Component)  // defau
 
 In `Component.test.js`:
 
-```js linenums="1"
+```js
 import React from "react";
 // import enzyme or react testing library
 
@@ -48,7 +48,7 @@ it("test description", () => {
 
 ## Tests for Action Creators
 
-```js linenums="1"
+```js
 import * as actions from "path/to/actionCreators";
 // import eventual action types constants
 // import mock data
@@ -65,7 +65,7 @@ it("test description", () => {
 
 ## Tests for Reducers
 
-```js linenums="1"
+```js
 import reducer from "path/to/reducer";
 import * as actions from "path/to/actionCreators";
 
@@ -83,7 +83,7 @@ it("test description", () => {
 
 ## Tests for the Store
 
-```js linenums="1"
+```js
 import { createStore } from "redux";
 
 import rootReducer from "path/to/rootReducer";
@@ -111,7 +111,7 @@ Thunk testing requires the mocking of:
 - store (using `redux-mock-store`)
 - HTTP calls (using `fetch-mock`)
 
-```js linenums="1"
+```js
 import thunk from "redux-thunk";
 import fetchMock from "fetch-mock";
 import configureMockStore from "redux-mock-store";

docs/languages/javascript/react/redux.md

@@ -11,7 +11,7 @@ By convention, that information is stored in a field called `payload`.
 
 **Action Creators** are functions that create and return action objects.
 
-```js linenums="1"
+```js
 function actionCreator(data)
 {
     return { type: ACTION_TYPE, payload: data };  // action obj
@@ -30,7 +30,7 @@ The store will run its reducer function and save the new state value inside.
 
 In `initialState.js`;
 
-```js linenums="1"
+```js
 export default {
     // initial state here
 }
@@ -38,7 +38,7 @@ export default {
 
 In `configStore.js`:
 
-```js linenums="1"
+```js
 // configStore.js
 import { createStore, applyMiddleware, compose } from "redux";
 
@@ -71,7 +71,7 @@ Reducers must **always** follow some specific rules:
   Instead, they must make *immutable updates*, by copying the existing `state` and making changes to the copied values.
 - They must not do any asynchronous logic, calculate random values, or cause other "side effects"
 
-```js linenums="1"
+```js
 import initialState from "path/to/initialState";
 
 function reducer(state = initialState, action) {
@@ -118,7 +118,7 @@ Presentational Components:
 
 Used at the root component and wraps all the application.
 
-```js linenums="1"
+```js
 // index.js
 import React from 'react';
 import ReactDOM from 'react-dom';
@@ -139,7 +139,7 @@ ReactDOM.render(
 );
 ```
 
-```js linenums="1"
+```js
 // Component.js
 import { connect } from 'react-redux';
 import { increment, decrement, reset } from './actionCreators';
@@ -183,7 +183,7 @@ A "thunk" is a function that wraps an expression to delay it's evaluation.
 
 In `configStore.js`:
 
-```js linenums="1"
+```js
 import { createStore, applyMiddleware, compose } from "redux";
 import thunk from "redux-thunk";
 
@@ -199,7 +199,7 @@ function configStore(initialState) {
 }
 ```
 
-```js linenums="1"
+```js
 // usually action on async func success
 function actionCreator(arg) {
     return { type: TYPE, data: arg };
@@ -241,7 +241,7 @@ Using Create React App​
 
 The recommended way to start new apps with React and Redux is by using the official Redux+JS template or Redux+TS template for Create React App, which takes advantage of Redux Toolkit and React Redux's integration with React components.
 
-```sh linenums="1"
+```sh
 # Redux + Plain JS template
 npx create-react-app my-app --template redux
 
@@ -286,7 +286,7 @@ Included Default Middleware​:
 
 Currently, the return value of `getDefaultMiddleware()` is:
 
-```js linenums="1"
+```js
 // development
 const middleware = [thunk, immutableStateInvariant, serializableStateInvariant]
 
@@ -294,7 +294,7 @@ const middleware = [thunk, immutableStateInvariant, serializableStateInvariant]
 const middleware = [thunk]
 ```
 
-```js linenums="1"
+```js
 
 import { combineReducers } from 'redux'
 import { configureStore } from '@reduxjs/toolkit'
@@ -320,7 +320,7 @@ export default store
 
 ### [`createAction`](https://redux-toolkit.js.org/api/createAction)
 
-```js linenums="1"
+```js
 import { createAction } from '@reduxjs/toolkit';
 
 const increment = createAction<number | undefined>('counter/increment');
@@ -333,7 +333,7 @@ increment.toString();  // 'counter/increment'
 
 ### [`createReducer`](https://redux-toolkit.js.org/api/createReducer)
 
-```js linenums="1"
+```js
 import { createAction, createReducer } from '@reduxjs/toolkit'
 
 interface CounterState {
@@ -368,7 +368,7 @@ Internally, it uses `createAction` and `createReducer`, so it's possible to use
 
 **Note**: action types will have the `<slice-name>/<reducer-name>` shape.
 
-```js linenums="1"
+```js
 import { createSlice, PayloadAction } from '@reduxjs/toolkit'
 
 interface CounterState {
@@ -415,7 +415,7 @@ The `payloadCreator` function will be called with two arguments:
 
 The logic in the `payloadCreator` function may use any of these values as needed to calculate the result.
 
-```js linenums="1"
+```js
 import { createAsyncThunk, createSlice } from '@reduxjs/toolkit'
 
 const payloadCreator = async (arg, ThunkAPI): Promise<T> => { /* ... */ };
@@ -444,7 +444,7 @@ It is intended to simplify common cases for loading data in a web application, e
 
 RTK Query is included within the installation of the core Redux Toolkit package. It is available via either of the two entry points below:
 
-```cs linenums="1"
+```cs
 import { createApi } from '@reduxjs/toolkit/query'
 
 /* React-specific entry point that automatically generates hooks corresponding to the defined endpoints */

docs/languages/javascript/svelte/svelte.md

@@ -1,6 +1,6 @@
 # [Svelte](https://svelte.dev/docs)
 
-```sh linenums="1"
+```sh
 npx degit sveltejs/template <project name>
 
 # set project to use typescript
@@ -12,7 +12,7 @@ npm init vite@latest
 
 ## App Entry-point
 
-```js linenums="1"
+```js
 import App from "./App.svelte"; // import the component
 
 const app = new App({
@@ -29,7 +29,7 @@ export default app;
 
 ### Basic Structure
 
-```html linenums="1"
+```html
 <!-- code for the component -->
 <script lang="ts">
   import { Component } from "Component.svelte";
@@ -57,7 +57,7 @@ export default app;
 
 ### If-Else
 
-```js linenums="1"
+```js
 {#if <condition>}
   // markup here
 {:else if <condition>}
@@ -69,7 +69,7 @@ export default app;
 
 ### Loops
 
-```js linenums="1"
+```js
 {#each array as item, index}  // index is optional
     // markup here
 {/each}
@@ -81,7 +81,7 @@ export default app;
 
 ### Await Blocks
 
-```js linenums="1"
+```js
 {#await promise}
  <p>...waiting</p>
 {:then number}
@@ -103,7 +103,7 @@ The full list of modifiers:
 - `once` — remove the handler after the first time it runs
 - `self` — only trigger handler if `event.target` is the element itself
 
-```js linenums="1"
+```js
 <script>
   const eventHandler = () => {};
 </script>
@@ -119,7 +119,7 @@ The full list of modifiers:
 
 ## Binding
 
-```html linenums="1"
+```html
 <script>
   let name = "Foo";
 </script>
@@ -137,7 +137,7 @@ Often, some parts of a component's state need to be computed from other parts an
 
 For these, Svelte has reactive declarations. They look like this:
 
-```js linenums="1"
+```js
 let count = 0;
 $: double =  count * 2;  // recalculated when count changes
 // or
@@ -149,7 +149,7 @@ $: <expression>
 
 [Svelte Routing](https://github.com/EmilTholin/svelte-routing)
 
-```js linenums="1"
+```js
 <!-- App.svelte -->
 <script>
   import { Router, Link, Route } from "svelte-routing";
@@ -177,14 +177,14 @@ $: <expression>
 
 ## Data Stores
 
-```js linenums="1"
+```js
 // stores.js
 import { writable } from "svelte/store";
 
 export const count = writable(0);
 ```
 
-```html linenums="1"
+```html
 <script>
   import { onDestroy } from "svelte";
   import { count } from ".path/to/stores.js";

docs/languages/kotlin/kotlin.md

@@ -2,7 +2,7 @@
 
 ## Package & Imports
 
-```kotlin linenums="1"
+```kotlin
 package com.app.uniqueID
 
 import <package>
@@ -10,7 +10,7 @@ import <package>
 
 ## Variable & Constants
 
-```kotlin linenums="1"
+```kotlin
 
 var variable: Type    //variable declaration
 var variable = value    //type can be omitted if it can be deduced by initialization
@@ -23,7 +23,7 @@ val CONSTANT_NAME: Type = value    //constant declaration
 For a variable to hold a null value, it must be of a nullable type.  
 Nullable types are specified suffixing `?` to the variable type.
 
-```kotlin linenums="1"
+```kotlin
 var nullableVariable: Type? = null
 
 nullableVariable?.method()    //correct way to use
@@ -37,7 +37,7 @@ nullablevariavle!!.method()    //unsafe way
 
 ### `If` - `Else If` - `Else`
 
-```kotlin linenums="1"
+```kotlin
 if (condition) {
     //code here
 } else if (condition) {
@@ -49,7 +49,7 @@ if (condition) {
 
 ### Conditional Expressions
 
-```kotlin linenums="1"
+```kotlin
 var variable: Type = if (condition) {
     //value to be assigned here
 } else if (condition) {
@@ -65,7 +65,7 @@ Each branch in a `when` expression is represented by a condition, an arrow (`->`
 If the condition on the left-hand side of the arrow evaluates to true, then the result of the expression on the right-hand side is returned.  
 Note that execution does not fall through from one branch to the next.
 
-```kotlin linenums="1"
+```kotlin
 when (variable){
     condition -> value
     condition -> value
@@ -90,7 +90,7 @@ when {
 
 ### `For` Loop
 
-```kotlin linenums="1"
+```kotlin
 for (item in iterable){
     //code here
 }
@@ -103,7 +103,7 @@ for(i in start..end) {
 
 ## Functions
 
-```kotlin linenums="1"
+```kotlin
 fun functionName(parameter: Type): Type {
     //code here
 
@@ -113,7 +113,7 @@ fun functionName(parameter: Type): Type {
 
 ### Simplifying Function Declarations
 
-```kotlin linenums="1"
+```kotlin
 fun functionName(parameter: Type): Type {
     return if (condition) {
         //returned value
@@ -132,7 +132,7 @@ fun functionName(parameter: Type): Type = if (condition) {
 
 ### Anonymous Functions
 
-```kotlin linenums="1"
+```kotlin
 val anonymousFunction: (Type) -> Type = { input ->
     //code acting on input here
 }
@@ -145,7 +145,7 @@ val variableName: Type = anonymousFunction(input)
 A function can take another function as an argument. Functions that use other functions as arguments are called *higher-order* functions.  
 This pattern is useful for communicating between components in the same way that you might use a callback interface in Java.
 
-```kotlin linenums="1"
+```kotlin
 fun functionName(parameter: Type, function: (Type) -> Type): Type {
     //invoke function
     return function(parameter)
@@ -156,7 +156,7 @@ fun functionName(parameter: Type, function: (Type) -> Type): Type {
 
 ### Class
 
-```kotlin linenums="1"
+```kotlin
 //primary constructor
 class ClassName(private var attribute: Type) {
 
@@ -177,7 +177,7 @@ class ClassName {
 
 [Companion Object Docs](https://kotlinlang.org/docs/tutorials/kotlin-for-py/objects-and-companion-objects.html)
 
-```kotlin linenums="1"
+```kotlin
 class ClassName {
 
     // in java: static
@@ -191,7 +191,7 @@ class ClassName {
 
 ### ArrayList
 
-```kotlin linenums="1"
+```kotlin
 var array:ArrayList<Type>? = null  // List init
 
 array.add(item)  //add item to list

docs/languages/markdown.md

@@ -2,7 +2,7 @@
 
 ## Headings
 
-```markdown linenums="1"
+```markdown
 Heading 1
 =========
 
@@ -16,7 +16,7 @@ Heading 2
 
 ## Text Formatting
 
-```markdown linenums="1"
+```markdown
 *Italic*    _Italic_
 **Bold**    __Bold__
 
@@ -25,7 +25,7 @@ Heading 2
 
 ## Links & Images
 
-```markdown linenums="1"
+```markdown
 [link text](http://b.org "title")
 
 [link text][anchor]
@@ -37,7 +37,7 @@ Heading 2
 [anchor]: http://url/b.jpg "title"
 ```
 
-```markdown linenums="1"
+```markdown
 > Blockquote
 
 * unordered list        - unordered list
@@ -54,16 +54,16 @@ Heading 2
 
 ### Horizontal rule
 
-```markdown linenums="1"
+```markdown
 ---                     ***
 ```
 
 ## Code
 
-```markdown linenums="1"
+```markdown
 `inline code`
 
-    ```lang linenums="1"
+    ```lang
     multi-line
     code block
     ```
@@ -71,7 +71,7 @@ Heading 2
 
 ## Table
 
-```markdown linenums="1"
+```markdown
 | column label | column label | column label  |
 |:-------------|:------------:|--------------:|
 | left-aligned | centered     | right-aligned |

docs/languages/php/composer.md

@@ -6,7 +6,7 @@ The function [spl_autoload_register()](https://www.php.net/manual/en/function.sp
 
 In `autoload.php`:
 
-```php linenums="1"
+```php
 # custom function
 function autoloader($class) {
 
@@ -31,7 +31,7 @@ spl_autoload_register('autoloader');  // register function
 
 In `file.php`:
 
-```php linenums="1"
+```php
 require "autoload.php";
 
 # other code
@@ -43,7 +43,7 @@ require "autoload.php";
 
 It's possible to resister multiple autoloading functions by calling `spl_autoload_register()` multiple times.
 
-```php linenums="1"
+```php
 # prepend adds the function at the start of the queue
 # throws selects if errors in loading throw exceptions
 spl_autoload_register(callable $func, $throw=TRUE, $prepend=FALSE);
@@ -60,7 +60,7 @@ Libraries are downloaded through [Packagist](https://packagist.org/) and [GitHub
 
 In `composer.json`:
 
-```json linenums="1"
+```json
 {
     "require": {
         "php": ">=7.0",
@@ -93,7 +93,7 @@ To update dependencies use `composer update`. To update only the autoloading sec
 
 Composer can also autoload classes belonging to the current project. It's sufficient to add the `autoload` keyword in the JSON and specify the path and autoload mode.
 
-```json linenums="1"
+```json
 {
     "autoload": {
         "psr-4": {

docs/languages/php/database.md

@@ -8,7 +8,7 @@ PDO is the PHP extension for database access through a single API. It supports v
 
 ### Database Connection
 
-```php linenums="1"
+```php
 $dsn = "mysql:dbname=<dbname>;host=<ip>";
 $user="<db_user>";
 $password="<db_password>";
@@ -25,7 +25,7 @@ try {
 
 To execute a query it's necessary to "prepare it" with *parameters*.
 
-```php linenums="1"
+```php
 # literal string with markers
 $sql = 'SELECT fields
 FROM tables
@@ -44,7 +44,7 @@ $result = $stmt->fetchAll(PDO::FETCH_CLASS, ClassName::class);  # result as obje
 
 ### Parameter Binding
 
-```php linenums="1"
+```php
 # bindValue
 $stmt = pdo->prepare(sql);
 $stmt->bindValue(':marker', value, PDO::PARAM_<type>);
@@ -64,7 +64,7 @@ Its possible to disable this behaviour setting `PDO::ATTR_STRINGIFY_FETCHES` and
 
 > **Note**: `FETCH_OBJ` abd `FETCH_CLASS` return classes and don't have this behaviour.
 
-```php linenums="1"
+```php
 pdo->setAttribute()
 
 $pdo->setAttribute(PDO::ATTR_STRINGIFY_FETCHES, false);
@@ -77,7 +77,7 @@ $result = $stmt->fetchAll(PDO::FETCH_ASSOC);
 
 ### PDO Debug
 
-```php linenums="1"
+```php
 $stmt = $pdo->prepare($sql);
 $stmt->execute([':marker' => value]);
 $result = $stmt->fetchAll(PDO::FETCH_ASSOC);
@@ -87,7 +87,7 @@ $stmt->debugDumpParams();  # print the SQL query that has been sent to the datab
 
 ## [SQLite3](https://www.php.net/manual/en/book.sqlite3.php)
 
-```php linenums="1"
+```php
 $db = SQLite3("db_file.sqlite3");  // connection
 
 $stmt = $db->prepare("SELECT fields FROM tables WHERE field <operator> :marker");  // prepare query

docs/languages/php/dependency-injection.md

@@ -2,7 +2,7 @@
 
 Explicit definition of a class dependencies with the injection through the constructor or *getters*/*setters*.
 
-```php linenums="1"
+```php
 class Foo
 {
     public function __construct(PDO $pdo)  // depends on PDO
@@ -24,7 +24,7 @@ The dependency injection container for humans. Installation: `composer require p
 - Use of [Reflection](https://www.php.net/manual/en/intro.reflection.php)
 - Configuration of the container through annotations & PHP code.
 
-```php linenums="1"
+```php
 class Foo
 {
     private $bar;
@@ -42,7 +42,7 @@ $foo = $container->get('Foo');  // get instance of Foo (automatic DI of Bar)
 
 ### DIC Configuration
 
-```php linenums="1"
+```php
 // Foo.php
 class Foo
 {
@@ -53,7 +53,7 @@ class Foo
 }
 ```
 
-```php linenums="1"
+```php
 // config.php
 use Psr\Container\ContainerInterface;
 
@@ -68,7 +68,7 @@ return [
 ];
 ```
 
-```php linenums="1"
+```php
 $builder = new \DI\ContainerBuilder();
 $builder->addDefinitions("config.php");  // load config
 $container = $builder->build();  // construct container

docs/languages/php/php.md

@@ -2,7 +2,7 @@
 
 [PHP Docs](https://www.php.net/docs.php)
 
-```php linenums="1"
+```php
 declare(strict_types=1);  # activates variable type checking on function arguments
 # single line comment
 //single line comment
@@ -11,7 +11,7 @@ declare(strict_types=1);  # activates variable type checking on function argumen
 
 ## Include, Require
 
-```php linenums="1"
+```php
 include "path\\file.php";  # import an external php file, E_WARNING if fails
 include_once "path\\file.php";  # imports only if not already loaded
 
@@ -23,7 +23,7 @@ require_once "path\\file.php";  # imports only if not already loaded
 
 In `config.php`:
 
-```php linenums="1"
+```php
 //config.php
 
 //store configuration options in associative array
@@ -33,7 +33,7 @@ return [
 ]
 ```
 
-```php linenums="1"
+```php
 $config = include "config.php";  // retrieve config and store into variable
 ```
 
@@ -41,7 +41,7 @@ $config = include "config.php";  // retrieve config and store into variable
 
 [PSR-4 Spec](https://www.php-fig.org/psr/psr-4/)
 
-```php linenums="1"
+```php
 namespace Foo\Bar\Baz;   # set namespace for all file contents, \ for nested namespaces
 
 use <PHP_Class>  # using a namespace hides standard php classes (WHY?!?)
@@ -68,7 +68,7 @@ fnn\func();  # use function from Foo\Bar\Baz
 
 ## Basics
 
-```php linenums="1"
+```php
 declare(strict_types=1);  # activates type checking
 # single line comment
 //single line comment
@@ -77,7 +77,7 @@ declare(strict_types=1);  # activates type checking
 
 ### Screen Output
 
-```php linenums="1"
+```php
 echo "string";  # string output
 echo 'string\n';  # raw string output
 printf("format", $variables);  # formatted output of strings and variables
@@ -86,7 +86,7 @@ sprintf("format", $variables);  # return formatted string
 
 ### User Input
 
-```php linenums="1"
+```php
 $var = readline("prompt");
 
 # if readline is not installed
@@ -105,7 +105,7 @@ if (!function_exists('readline')) {
 
 ## Variables
 
-```php linenums="1"
+```php
 $variableName = value;  # weakly typed
 echo gettype(&variable);  # output type of variable
 
@@ -114,7 +114,7 @@ var_dump($var);  # prints info of variable (bit dimension, type & value)
 
 ### Integers
 
-```php linenums="1"
+```php
 &max = PHP_INT_MAX;  # max value for int type -> 9223372036854775807
 &min = PHP_INT_MIN;  # min value for int type -> -9223372036854775808
 &bytes = PHP_INT_SIZE;  # bytes for int type -> 8
@@ -127,7 +127,7 @@ var_dump($var);  # prints info of variable (bit dimension, type & value)
 
 ### Double
 
-```php linenums="1"
+```php
 $a = 1.234; // 1.234
 $b = 1.2e3; // 1200
 $c = 7E-10; // 0.0000000007
@@ -163,14 +163,14 @@ A string is a sequence of ASCII characters. In PHP a string is an array of chara
 
 ### String Concatenation
 
-```php linenums="1"
+```php
 $string1 . $string2; # method 1
 $string1 .= $string2;  # method 2
 ```
 
 ### String Functions
 
-```php linenums="1"
+```php
 strlen($string);  # returns the string length
 strpos($string, 'substring');  # position of substring in string
 substr($string, start, len);  # extract substring of len from position start
@@ -184,7 +184,7 @@ $var = sprintf("format", $variables)  # construct and return a formatted string
 
 ## Constants
 
-```php linenums="1"
+```php
 define ('CONSTANT_NAME', 'value')
 ```
 
@@ -201,7 +201,7 @@ define ('CONSTANT_NAME', 'value')
 
 Heterogeneous sequence of values.
 
-```php linenums="1"
+```php
 $array = (sequence_of_items);  # array declaration and valorization
 $array = [sequence_of_items];  # array declaration and valorization
 
@@ -216,7 +216,7 @@ $array[] = value;  # value appending
 
 Array of array. Can have arbitrary number of nested array
 
-```php linenums="1"
+```php
 $matrix = [
     [1, 2, 3],
     [4, 5, 6],
@@ -228,14 +228,14 @@ $matrix = [
 
 Single instruction to print whole array is ``
 
-```php linenums="1"
+```php
 $array = [1, 2, 3];
 print_r($array);  # print all the array values
 ```
 
 ### Array Functions
 
-```php linenums="1"
+```php
 count($array);  # returns number of items in the array
 array_sum($array)  # sum of the array value
 sort($array);  # quick sort
@@ -263,7 +263,7 @@ list($array1 [, $array2, ...]) = $data;  # Python-like tuple unpacking
 
 Associative arrays have a value as an index. Alternative names are _hash tables_ or _dictionaries_.
 
-```php linenums="1"
+```php
 $italianDay = [
     'Mon' => 'Lunedì',
     'Tue' => 'Martedì',
@@ -309,14 +309,14 @@ With `==` a string evaluates to `0`.
 
 ### Ternary Operator
 
-```php linenums="1"
+```php
 condition ? result_if_true : result_if_false;
 condition ?: result_if_false;
 ```
 
 ### NULL Coalesce
 
-```php linenums="1"
+```php
 $var1 = $var2 ?? value;  # if variable == NULL assign value, otherwise return value of $var2
 
 # equivalent to
@@ -325,7 +325,7 @@ $var1 = isset($var2) ? $var2 : value
 
 ### Spaceship Operator
 
-```php linenums="1"
+```php
 $a <=> $b;
 
 # equivalent to
@@ -339,7 +339,7 @@ if $a < $b
 
 ### `If` - `Elseif` - `Else`
 
-```php linenums="1"
+```php
 if (condition) {
   # code here
 } elseif (condition) {
@@ -359,7 +359,7 @@ endif;
 
 ### Switch Case
 
-```php linenums="1"
+```php
 # weak comparison
 switch ($var) {
     case value:
@@ -385,7 +385,7 @@ switch (true) {
 
 `match` can return values, doesn't require break statements, can combine conditions, uses strict type comparisons and doesn't do any type coercion.
 
-```php linenums="1"
+```php
 $result = match($input) {
     0 => "hello",
     '1', '2', '3' => "world",
@@ -396,7 +396,7 @@ $result = match($input) {
 
 ### For, Foreach
 
-```php linenums="1"
+```php
 for (init, condition, increment){
     # code here
 }
@@ -421,7 +421,7 @@ foreach($sequence as $key => $value) {
 
 ### While, Do-While
 
-```php linenums="1"
+```php
 while (condition) {
     # code here
 }
@@ -447,7 +447,7 @@ do {
 
 Parameters with default values are optional in the function call and must be the last ones in the function declaration. Return type is optional if type checking is disabled.
 
-```php linenums="1"
+```php
 declare(strict_types=1);  # activates type checking
 
 /**
@@ -475,7 +475,7 @@ function functionName (type $parameter, $parameter = default_value): Type
 
 ### Void function
 
-```php linenums="1"
+```php
 function functionName (type $parameter, $parameter = default_value): Void
 {
     # code here
@@ -484,7 +484,7 @@ function functionName (type $parameter, $parameter = default_value): Void
 
 ### Passing a parameter by reference (`&$`)
 
-```php linenums="1"
+```php
 function functionName (type &$parameter): Type
 {
     # code here
@@ -494,7 +494,7 @@ function functionName (type &$parameter): Type
 
 ### Variable number of parameters, variadic operator (`...`)
 
-```php linenums="1"
+```php
 function functionName (type $parameter, ...$args): Type
 function functionName (type $parameter, type ...$args): Type
 {
@@ -505,7 +505,7 @@ function functionName (type $parameter, type ...$args): Type
 
 ### Nullable parameters
 
-```php linenums="1"
+```php
 function functionName (?type $parameter): ?Type
 {
     # code here
@@ -515,7 +515,7 @@ function functionName (?type $parameter): ?Type
 
 ## Anonymous Functions (Closure)
 
-```php linenums="1"
+```php
 # declaration and assignment to variable
 $var = function (type $parameter) {
     # code here
@@ -526,7 +526,7 @@ $var($arg);
 
 ### Use Operator
 
-```php linenums="1"
+```php
 # use imports a variable into the closure
 $foo = function (type $parameter) use ($average) {
     # code here
@@ -537,7 +537,7 @@ $foo = function (type $parameter) use ($average) {
 
 **Union types** are a collection of two or more types which indicate that _either_ one of those _can be used_.
 
-```php linenums="1"
+```php
 public function foo(Foo|Bar $input): int|float;
 ```
 
@@ -546,7 +546,7 @@ public function foo(Foo|Bar $input): int|float;
 Named arguments allow to pass in values to a function, by specifying the value name, to avoid taking their order into consideration.
 It's also possible to skip optional parameters.
 
-```php linenums="1"
+```php
 function foo(string $a, string $b, ?string $c = null, ?string $d = null) { /* … */ }
 
 foo(
@@ -568,7 +568,7 @@ foo(
 
 ### Class Declaration & Instantiation
 
-```php linenums="1"
+```php
 # case insensitive
 class ClassName
 {
@@ -611,7 +611,7 @@ $object instanceof ClassName  // check type of the object
 Inside static methods it's impossible to use `$this`.
 A static variable is unique for the class and all instances.
 
-```php linenums="1"
+```php
 class ClassName {
 
     public static $var;
@@ -636,7 +636,7 @@ $obj::$var;  // access to the static variable
 
 Parameters of the dependency can be modified before passing the required class to the constructor.
 
-```php linenums="1"
+```php
 class ClassName
 {
     private $dependency;
@@ -653,7 +653,7 @@ class ClassName
 If a class is defined `final` it can't be extended.
 If a function is declared `final` it can't be overridden.
 
-```php linenums="1"
+```php
 class Child extends Parent
 {
     public __construct() {
@@ -666,7 +666,7 @@ class Child extends Parent
 
 Abstract classes cannot be instantiated;
 
-```php linenums="1"
+```php
 abstract class ClassName
 {
     # code here
@@ -679,7 +679,7 @@ An interface is a "contract" that defines what methods the implementing classes
 
 A class can implement multiple interfaces but there must be no methods in common between interface to avoid ambiguity.
 
-```php linenums="1"
+```php
 interface InterfaceName {
 
     // it is possible to define __construct
@@ -703,7 +703,7 @@ It can be used to mitigate the problem of _multiple inheritance_, which is absen
 
 In case of functions name conflict it's possible to use `insteadof` to specify which function to use. It's also possible to use an _alias_ to resolve the conflicts.
 
-```php linenums="1"
+```php
 trait TraitName {
     // code here
 }
@@ -716,7 +716,7 @@ class ClassName {
 
 ### Anonymous Classes
 
-```php linenums="1"
+```php
 $obj = new ClassName;
 
 $obj->method(new class implements Interface {
@@ -728,7 +728,7 @@ $obj->method(new class implements Interface {
 
 ## Serialization & JSON
 
-```php linenums="1"
+```php
 $serialized = serialize($obj);  # serialization
 $obj = unserialize($serialized);  # de-serialization
 
@@ -740,7 +740,7 @@ $json = json_encode($value);  # Returns a string containing the JSON representat
 
 ### Read/Write on Files
 
-```php linenums="1"
+```php
 file(filename);  // return file lines in an array
 
 // problematic with large files (allocates memory to read all file, can fill RAM)
@@ -750,7 +750,7 @@ file_get_contents(filename);  // read whole file
 
 ## Regular Expressions
 
-```php linenums="1"
+```php
 preg_match('/PATTERN/', string $subject, array $matches);  # returns 1 if the pattern matches given subject, 0 if it does not, or FALSE if an error occurred
 # $matches[0] = whole matched string
 # $matches[i] = i-th group of the regex
@@ -774,7 +774,7 @@ Supported hashing algrithms:
 - `joaat`
 - `haval128,3`, `haval160,3`, `haval192,3`, `haval224,3`, `haval256,3`, `haval128,4`, `haval160,4`, `haval192,4`, `haval224,4`, `haval256,4`, `haval128,5`, `haval160,5`, `haval192,5`, `haval224,5`, `haval256,5`
 
-```php linenums="1"
+```php
 hash($algorithm, $data);
 ```
 
@@ -804,7 +804,7 @@ Algorithms currently supported:
 - **time_cost** (integer) - Maximum amount of time it may take to compute the Argon2 hash. Defaults to PASSWORD_ARGON2_DEFAULT_TIME_COST.
 - **threads** (integer) - Number of threads to use for computing the Argon2 hash. Defaults to PASSWORD_ARGON2_DEFAULT_THREADS.
 
-```php linenums="1"
+```php
 password_hash($password, $algorithm);  # create a new password hash using a strong one-way hashing algorithm.
 password_verify($password, $hash);  # Verifies that a password matches a hash
 ```
@@ -817,17 +817,17 @@ Types of PHP errors:
 - **Warning**: generated at runtime, does not stop the execution (non-blocking).
 - **Notice**: informative errors or messages, non-blocking.
 
-```php linenums="1"
+```php
 $a = new StdClass()
 $a->foo();  // PHP Fatal Error: foo() does not exist
 ```
 
-```php linenums="1"
+```php
 $a = 0;
 echo 1/$a;  // PHP Warning: Division by zero
 ```
 
-```php linenums="1"
+```php
 echo $a;  // PHP Notice: $a undefined
 ```
 
@@ -837,7 +837,7 @@ echo $a;  // PHP Notice: $a undefined
 
 Its possible to configure PHP to signal only some type of errors. Errors below a certain levels are ignored.
 
-```php linenums="1"
+```php
 error_reporting(E_<type>);  // set error report threshold (for log file)
 // does not disable PARSER ERROR
 
@@ -847,7 +847,7 @@ ini_set("error_log", "path\\error.log");  // set log file
 
 ### Triggering Errors
 
-```php linenums="1"
+```php
 // generate E_USER_ errors
 trigger_error("message");  // default type: E_USER_NOTICE
 trigger_error("message", E_USER_<Type>);
@@ -859,7 +859,7 @@ trigger_error("Deprecated Function", E_USER_DEPRECATED);
 
 It's possible to use log files unrelated to the php log file.
 
-```php linenums="1"
+```php
 error_log("message", 3, "path\\log.log");  // write log message to a specified file
 
 //example
@@ -870,7 +870,7 @@ error_log(sprintf("[%s] Error: _", date("Y-m-d h:i:s")), 3, "path\\log.log")
 
 PHP offers the possibility to handle errors with the _exception model_.
 
-```php linenums="1"
+```php
 try {
     // dangerous code
 } catch(ExceptionType1 | ExceptionType2 $e) {
@@ -884,7 +884,7 @@ throw new ExceptionType("message");  // throw an exception
 
 All exceptions in PHP implement the interface `Throwable`.
 
-```php linenums="1"
+```php
 Interface Throwable {
     abstract public string getMessage ( void )
     abstract public int getCode ( void )
@@ -899,7 +899,7 @@ Interface Throwable {
 
 ### Custom Exceptions
 
-```php linenums="1"
+```php
 /**
  * Define a custom exception class
  */

docs/languages/php/plates-templating.md

@@ -6,7 +6,7 @@ To separate HTML code and PHP code it's possible to use **templates** with marke
 Variables are created in the PHP code and are passed to the template in the **rendering** phase.
 The server transmits only the `index.php` file to the user. The php file renders the templates as needed.
 
-```html linenums="1"
+```html
 <html>
     <head>
         <title><?= $this->e($title)?></title>
@@ -24,7 +24,7 @@ Plates is a template engine for PHP. A template engine permits to separate the P
 
 Installation through composer: `composer require league/plates`.
 
-```php linenums="1"
+```php
 # index.php
 require "vendor/autoload.php";
 
@@ -38,7 +38,7 @@ echo $templates->render("template_name", [
 ]);
 ```
 
-```php linenums="1"
+```php
 # template.php
 <html>
     <head>
@@ -60,7 +60,7 @@ In a layout it's possible to create a section called **content** that identifies
 
 > **Note**: Since only the template has the data passed eventual loops have to be done there.
 
-```php linenums="1"
+```php
 # index.php
 require 'vendor/autoload.php';
 use League\Plates\Engine;
@@ -68,7 +68,7 @@ $template = new Engine('/path/to/templates');
 echo $template->render('template_name', [ "marker" => value, ... ]);
 ```
 
-```php linenums="1"
+```php
 # template.php
 
 # set the layout used for this template
@@ -78,7 +78,7 @@ echo $template->render('template_name', [ "marker" => value, ... ]);
 <p> <?= $this->e($marker) ?> </p>
 ```
 
-```php linenums="1"
+```php
 # layout.php
 <html>
     <head>
@@ -101,7 +101,7 @@ In general the output validation allows to prevent [Cross-Site Scripting][owasp-
 
 ### Folders
 
-```php linenums="1"
+```php
 # index.php
 $templates->addFolder("alias", "path/to/template/folder");  # add a template folder
 echo $templates->render("folder::template");  # use a template in a specific folder
@@ -111,7 +111,7 @@ echo $templates->render("folder::template");  # use a template in a specific fol
 
 It's possible to inject templates in a layout or template. It is done by using the `insert()` function.
 
-```php linenums="1"
+```php
 # layout.php
 <html>
     <head>
@@ -132,7 +132,7 @@ It's possible to inject templates in a layout or template. It is done by using t
 It's possible to insert page contest from another template with the `section()` function.
 The content to be inserted must be surrounded with by the `start()` and `stop()` functions.
 
-```php linenums="1"
+```php
 # template.php
 
 <?php $this->start("section_name") ?>  # start section

docs/languages/php/psr-7.md

@@ -14,7 +14,7 @@ Standard of the PHP Framework Interop Group that defines common interfaces for h
 
 Example:
 
-```php linenums="1"
+```php
 // empty array if not found
 $header = $request->getHeader('Accept');
 

docs/languages/php/simple-mvc/rest-api.md

@@ -2,7 +2,7 @@
 
 ## Routing (Example)
 
-```php linenums="1"
+```php
 // config/route.php
 return [   
    [ 'GET', '/api/user[/{id}]', Controller\User::class ],
@@ -14,7 +14,7 @@ return [
 
 ## Controller (Example)
 
-```php linenums="1"
+```php
 public class UserController implements ControllerInterface
 {
     public function __construct(UserModel $user)

docs/languages/php/simple-mvc/simple-mvc.md

@@ -10,13 +10,13 @@ This framework is mainly used as tutorial for introducing the Model-View-Control
 
 ## Installation
 
-```ps1 linenums="1"
+```ps1
 composer create-project ezimuel/simple-mvc
 ```
 
 ## Structure
 
-```txt linenums="1"
+```txt
 |- config
 |  |- container.php --> DI Container Config (PHP-DI)
 |  |- route.php --> routing
@@ -34,7 +34,7 @@ composer create-project ezimuel/simple-mvc
 
 ### `index.php`
 
-```php linenums="1"
+```php
 <?php
 declare(strict_types=1);
 
@@ -98,7 +98,7 @@ $controller->execute($request);
 
 ### `route.php`
 
-```php linenums="1"
+```php
 <?php
 use SimpleMVC\Controller;
 
@@ -111,7 +111,7 @@ return [
 
 ### `container.php`
 
-```php linenums="1"
+```php
 <?php
 use League\Plates\Engine;
 use Psr\Container\ContainerInterface;
@@ -130,7 +130,7 @@ return [
 
 Each controller *must* implement this interface.
 
-```php linenums="1"
+```php
 <?php
 declare(strict_types=1);
 

docs/languages/php/unit-tests.md

@@ -4,11 +4,11 @@
 
 ### Dev-Only Installation
 
-```ps1 linenums="1"
+```ps1
 composer require --dev phpunit/phpunit
 ```
 
-```json linenums="1"
+```json
     "require-dev": {
         "phpunit/phpunit": "<version>"
     }
@@ -18,7 +18,7 @@ composer require --dev phpunit/phpunit
 
 PHPUnit can be configured in a XML file called `phpunit.xml`:
 
-```xml linenums="1"
+```xml
 <phpunit xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:noNamespaceSchemaLocation="vendor/phpunit/phpunit/phpunit.xsd"
          bootstrap="vendor/autoload.php"
@@ -46,7 +46,7 @@ PHPUnit can be configured in a XML file called `phpunit.xml`:
 A test is a method of a *test class* prefixed with `test`.  
 PHPUnit is executed from the command line with `vendor/bin/phpunit  --colors`.
 
-```php linenums="1"
+```php
 namespace App;
 
 class Filter
@@ -58,7 +58,7 @@ class Filter
 }
 ```
 
-```php linenums="1"
+```php
 namespace App\Test;
 use PHPUnit\Framework\TestCase;
 use App\Filter;
@@ -92,7 +92,7 @@ class FilterTest extends TestCase
 
 ### [PHPUnit Testing Exceptions](https://phpunit.readthedocs.io/en/9.3/writing-tests-for-phpunit.html#testing-exceptions)
 
-```php linenums="1"
+```php
 public function testAggiungiEsameException(string $esame)
 {
     $this->expectException(Exception::class);
@@ -131,7 +131,7 @@ public function testNoExceptions(string $esame)
 
 ### Test Setup & Teardown (Example)
 
-```php linenums="1"
+```php
 class ClassTest extends TestCase
 {
     // initialize the test
@@ -157,7 +157,7 @@ class ClassTest extends TestCase
 
 ### Data Provider
 
-```php linenums="1"
+```php
 class DataTest extends TestCase
 {
     /**
@@ -195,7 +195,7 @@ class DataTest extends TestCase
 
 ### Mock Objects
 
-```php linenums="1"
+```php
 class UnitTest extends TestCase
 {
     public function setUp()
@@ -225,6 +225,6 @@ class UnitTest extends TestCase
 
 ### Code Coverage (needs [XDebug](https://xdebug.org/))
 
-```ps1 linenums="1"
+```ps1
 vendor/bin/phpunit --coverage-text  # code coverage analysis in the terminal
 ```

docs/languages/php/web.md

@@ -4,7 +4,7 @@
 
 Command Line Web Server in PHP, useful in testing phase. Limited since handles only one request at a time. **Do not use in production**.
 
-```ps1 linenums="1"
+```ps1
 PHP -S <ip:post>  # start web server
 PHP -S <ip:post> -t /path/to/folder  # execute in specified folder at specified address
 PHP -S <ip:post> file.php  # redirect requests to single file
@@ -22,7 +22,7 @@ Handling of HTTP requests happens using the following global variables:
 
 ### `$_FILES`
 
-```html linenums="1"
+```html
 <!-- method MUST BE post -->
 <!-- must have enctype="multipart/form-data" attribute -->
 <form name="<name>" action="file.php" method="POST" enctype="multipart/form-data">
@@ -33,7 +33,7 @@ Handling of HTTP requests happens using the following global variables:
 
 Files in `$_FILES` are memorized in a system temp folder. They can be moved with `move_uploaded_file()`
 
-```php linenums="1"
+```php
 if (! isset($_FILES['photo']['error'])) {
     http_response_code(400);  # send a response code
     echo'<h1>No file has been sent</h1>';
@@ -61,7 +61,7 @@ echo'<h1>File successfully sent</h1>';
 
 Request Header Access:
 
-```php linenums="1"
+```php
 $_SERVER["REQUEST_METHOD"];
 $_SERVER["REQUEST_URI"];
 $_SERVER["SERVER_PROTOCOL"];  // HTTP Versions
@@ -83,7 +83,7 @@ All sites **must** have a page for the consensus about using cookies.
 **Cookies** are HTTP headers used to memorize key-value info *on the client*. They are sent from the server to the client to keep track of info on the user that is visiting the website.  
 When a client receives a HTTP response that contains `Set-Cookie` headers it has to memorize that info and reuse them in future requests.
 
-```http linenums="1"
+```http
 Set-Cookie: <cookie-name>=<cookie-value>
 Set-Cookie: <cookie-name>=<cookie-value>; Expires=<date>
 Set-Cookie: <cookie-name>=<cookie-value>; Max-Age=<seconds>
@@ -97,13 +97,13 @@ Anyone can modify the contents of a cookie; for this reason cookies **must not c
 
 When a client has memorized a cookie, it is sent in successive HTTP requests through the `Cookie` header.
 
-```http linenums="1"
+```http
 Cookie: <cookie-name>=<cookie-value>
 ```
 
 [PHP setcookie docs](https://www.php.net/manual/en/function.setcookie.php)
 
-```php linenums="1"
+```php
 setcookie (
 string $name,
 [ string $value = "" ],
@@ -130,7 +130,7 @@ PHP generates a cookie named `PHPSESSID` containing a *session identifier* and a
 To use the session it's necessary to recall the function `session_start()` at the beginning of a PHP script that deals with sessions.  
 After starting the session information in be saved in the `$_SESSION` array.
 
-```php linenums="1"
+```php
 $_SESSION["key"] = value;  // save data in session file (serialized data)
 
 unset($_SESSION["key"]);  // delete data from the session

docs/languages/powershell/commands.md

@@ -1,6 +1,6 @@
 # Powershell Commands
 
-```ps1 linenums="1"
+```ps1
 Get-Location  # Gets information about the current working location or a location stack
 Set-Location -Path <path>  # change current working directory to specified path (DEFAULTs to ~)
 Get-ChildItem  -Path <path>  # Gets the items and child items in one or more specified locations.

docs/languages/powershell/scripting.md

@@ -11,20 +11,20 @@ If you do call a cmdlet/PS function with parentheses, it is the same as passing
 
 ## Screen Output
 
-```ps1 linenums="1"
+```ps1
 Write-Host "message"
 ```
 
 ## User Input
 
-```ps1 linenums="1"
+```ps1
 # Reading a value from input:
 $variable = Read-Host "prompt"
 ```
 
 ## Variables
 
-```ps1 linenums="1"
+```ps1
 # Declaration
 [type]$var = value
 $var = value -as [type]
@@ -52,7 +52,7 @@ Write-Host (<expression>)
 
 ### Built-in Variables
 
-```ps1 linenums="1"
+```ps1
 $True, $False  # boolean
 $null  # empty value
 $?  # last program return value
@@ -71,7 +71,7 @@ $Args # Unbound arguments
 
 ### Lists & Dictionaries
 
-```ps1 linenums="1"
+```ps1
 $List = @(5, "ice", 3.14, $True)  # Explicit syntax
 $List = 2, "ice", 3.14, $True  # Implicit syntax
 $List = (1..10)  # Inclusive range
@@ -93,7 +93,7 @@ foreach ($k in $Dict.keys) {
 
 ## Flow Control
 
-```ps1 linenums="1"
+```ps1
 if (condition) {
     # Code here
 } elseif (condition) {
@@ -113,7 +113,7 @@ if (condition) {
 - **File**: Takes input from a file rather than a value statement. If multiple File parameters are included, only the last one is used. Each line of the file is read and evaluated by the Switch statement. The comparison is case-insensitive.
 - **Regex**: Performs regular expression matching of the value to the condition. If the match clause is not a string, this parameter is ignored. The comparison is case-insensitive. The `$matches` automatic variable is available for use within the matching statement block.
 
-```ps1 linenums="1"
+```ps1
 switch(variable) {
     20                      { "Exactly 20"; break }
     { $_ -eq 42 }           { "The answer equals 42"; break }
@@ -142,7 +142,7 @@ switch [-regex|-wildcard|-exact][-casesensitive] -file filename
 
 ### Loops
 
-```ps1 linenums="1"
+```ps1
 # The classic for
 for(setup; condition; iterator) {
     # Code here
@@ -169,7 +169,7 @@ do {
 
 ### Operators
 
-```ps1 linenums="1"
+```ps1
 # Conditionals
 $a -eq $b  # is equal to
 $a -ne $b  # in not equal to
@@ -186,7 +186,7 @@ $True -Or $False
 
 ### Exception Handling
 
-```ps1 linenums="1"
+```ps1
 try {} catch {} finally {}
 try {} catch [System.NullReferenceException] {
     echo $_.Exception | Format-List -Force
@@ -195,7 +195,7 @@ try {} catch [System.NullReferenceException] {
 
 ## [Functions](https://docs.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_functions?view=powershell-7)
 
-```ps1 linenums="1"
+```ps1
 function func() {}
 
 # function with named parameters
@@ -221,7 +221,7 @@ If the function defines a `Begin`, `Process` or `End` block, all the code **must
 
 If the function has a `Process` keyword, each object in `$input` is removed from `$input` and assigned to `$_`.
 
-```ps1 linenums="1"
+```ps1
 function [<scope:>]<name> [([type]$parameter1[,[type]$parameter2])]
 {
   param([type]$parameter1 [,[type]$parameter2])  # other way to specify named parameters
@@ -236,7 +236,7 @@ function [<scope:>]<name> [([type]$parameter1[,[type]$parameter2])]
 
 Optionally, it's possible to provide a brief help string that describes the default value of the parameter, by adding the `PSDefaultValue` attribute to the description of the parameter, and specifying the `Help` property of `PSDefaultValue`.
 
-```ps1 linenums="1"
+```ps1
 function Func {
   param (
       [PSDefaultValue(Help = defValue)]
@@ -249,7 +249,7 @@ function Func {
 
 ### Parsing Script Arguments
 
-```ps1 linenums="1"
+```ps1
 $args  # array of passed arguments
 $args[$index]  # access to the arguments
 $args.count  # number of arguments
@@ -259,7 +259,7 @@ $args.count  # number of arguments
 
 In `scripts.ps1`:
 
-```ps1 linenums="1"
+```ps1
 param($param1, $param2, ...)  # basic usage
 param($param1, $param2=defvalue, ...)  # with default values
 param([Type] $param1, $param2, ...)  # specify a type
@@ -270,7 +270,7 @@ param([switch]$flag=$false, ...)  # custom flags
 
 In PowerShell:
 
-```ps1 linenums="1"
+```ps1
 .\script.ps1 arg1 arg2  # order of arguments will determine which data goes in which parameter
 
 .\script.ps1 -param2 arg2 -param1 arg1  # custom order
@@ -280,7 +280,7 @@ In PowerShell:
 
 A filter is a type of function that runs on each object in the pipeline. A filter resembles a function with all its statements in a `Process` block.
 
-```ps1 linenums="1"
+```ps1
 filter [<scope:>]<name> {<statement list>}
 ```
 
@@ -288,14 +288,14 @@ filter [<scope:>]<name> {<statement list>}
 
 The syntax for comment-based help is as follows:
 
-```ps1 linenums="1"
+```ps1
 # .<help keyword>
 # <help content>
 ```
 
 or
 
-```ps1 linenums="1"
+```ps1
 <#
 .<help keyword>
 <help content>
@@ -322,7 +322,7 @@ The description of a parameter. Add a `.PARAMETER` keyword for each parameter in
 
 Type the parameter name on the same line as the `.PARAMETER` keyword. Type the parameter description on the lines following the `.PARAMETER` keyword. Windows PowerShell interprets all text between the `.PARAMETER` line and the next keyword or the end of the comment block as part of the parameter description. The description can include paragraph breaks.
 
-```ps1 linenums="1"
+```ps1
 .PARAMETER  <Parameter-Name>
 ```
 
@@ -332,7 +332,7 @@ You can also specify a parameter description by placing a comment in the functio
 
 If you use both a syntax comment and a `.PARAMETER` keyword, the description associated with the `.PARAMETER` keyword is used, and the syntax comment is ignored.
 
-```ps1 linenums="1"
+```ps1
 <#
 .SYNOPSIS
     Short description here
@@ -389,7 +389,7 @@ The keywords that describe the intended use of the function. The **Functionality
 
 Redirects to the help topic for the specified command. You can redirect users to any help topic, including help topics for a function, script, cmdlet, or provider.
 
-```ps1 linenums="1"
+```ps1
 # .FORWARDHELPTARGETNAME <Command-Name>
 ```
 
@@ -397,7 +397,7 @@ Redirects to the help topic for the specified command. You can redirect users to
 
 Specifies the help category of the item in `.ForwardHelpTargetName`. Valid values are `Alias`, `Cmdlet`, `HelpFile`, `Function`, `Provider`, `General`, `FAQ`, `Glossary`, `ScriptCommand`, `ExternalScript`, `Filter`, or `All`. Use this keyword to avoid conflicts when there are commands with the same name.
 
-```ps1 linenums="1"
+```ps1
 # .FORWARDHELPCATEGORY <Category>
 ```
 
@@ -406,7 +406,7 @@ Specifies the help category of the item in `.ForwardHelpTargetName`. Valid value
 Specifies a session that contains the help topic. Enter a variable that contains a **PSSession** object. This keyword is used by the [Export-PSSession](https://docs.microsoft.com/en-us/powershell/module/microsoft.powershell.utility/export-pssession?view=powershell-7)
 cmdlet to find the help topics for the exported commands.
 
-```ps1 linenums="1"
+```ps1
 # .REMOTEHELPRUNSPACE <PSSession-variable>
 ```
 
@@ -414,7 +414,7 @@ cmdlet to find the help topics for the exported commands.
 
 Specifies an XML-based help file for the script or function.
 
-```ps1 linenums="1"
+```ps1
 # .EXTERNALHELP <XML Help File>
 
 ```
@@ -425,7 +425,7 @@ The `.ExternalHelp` keyword takes precedence over other comment-based help keywo
 
 If the function is exported by a module, set the value of the `.ExternalHelp` keyword to a filename without a path. `Get-Help` looks for the specified file name in a language-specific subdirectory of the module directory. There are no requirements for the name of the XML-based help file for a function, but a best practice is to use the following format:
 
-```ps1 linenums="1"
+```ps1
 <ScriptModule.psm1>-help.xml
 ```
 
@@ -439,7 +439,7 @@ For more information about the cmdlet help XML-based help file format, see [How
 
 ### Classes
 
-```ps1 linenums="1"
+```ps1
 [class]::func()  # use function from a static class
 [class]::attribute  # access to static class attribute
 ```

docs/languages/python/libs/beautiful-soup.md

@@ -2,7 +2,7 @@
 
 ## Making the Soup
 
-```py linenums="1"
+```py
 
 from bs4 import BeautifulSoup
 import requests
@@ -24,7 +24,7 @@ Beautiful Soup transforms a complex HTML document into a complex tree of Python
 
 A Tag object corresponds to an XML or HTML tag in the original document
 
-```py linenums="1"
+```py
 soup = BeautifulSoup('<b class="boldest">Extremely bold</b>', 'html.parser')  # parse HTML/XML
 
 tag = soup.b
@@ -44,7 +44,7 @@ A string corresponds to a bit of text within a tag. Beautiful Soup uses the `Nav
 
 ### Going Down
 
-```py linenums="1"
+```py
 soup.<tag>.<child_tag>  # navigate using tag names
 
 <tag>.contents  # direct children as a list
@@ -61,14 +61,14 @@ soup.<tag>.<child_tag>  # navigate using tag names
 
 ### Going Up
 
-```py linenums="1"
+```py
 <tag>.parent  # tags direct parent (BeautifulSoup has parent None, html has parent BeautifulSoup)
 <tag>.parents  # iterable over all parents
 ```
 
 ### Going Sideways
 
-```py linenums="1"
+```py
 <tag>.previous_sibling
 <tag>.next_sibling
 
@@ -78,7 +78,7 @@ soup.<tag>.<child_tag>  # navigate using tag names
 
 ### Going Back and Forth
 
-```py linenums="1"
+```py
 <tag>.previous_element  # whatever was parsed immediately before
 <tag>.next_element # whatever was parsed immediately afterwards
 
@@ -90,7 +90,7 @@ soup.<tag>.<child_tag>  # navigate using tag names
 
 ## Filter Types
 
-```py linenums="1"
+```py
 soup.find_all("tag")  # by name
 soup.find_all(["tag1", "tag2"])  # multiple tags in a list
 soup.find_all(function)  # based on a bool function
@@ -107,7 +107,7 @@ Methods arguments:
 - `limit` (int). limit number of results
 - `**kwargs`: be turned into a filter on one of a tag's attributes.
 
-```py linenums="1"
+```py
 find_all(name, attrs, recursive, string, limit, **kwargs)  # several results
 find(name, attrs, recursive, string, **kwargs)  # one result
 
@@ -135,7 +135,7 @@ soup.select("css_selector")  # search for CSS selectors of HTML tags
 
 ### Changing Tag Names an Attributes
 
-```py linenums="1"
+```py
 <tag>.name = "new_html_tag"  # modify the tag type
 <tag>["attribute"]  = "value"  # modify the attribute value
 del <tag>["attribute"]  # remove the attribute

docs/languages/python/libs/numpy.md

@@ -2,7 +2,7 @@
 
 ## MOST IMPORTANT ATTRIBUTES ATTRIBUTES
 
-```py linenums="1"
+```py
 array.ndim     # number of axes (dimensions) of the array
 array.shape  # dimensions of the array, tuple of integers
 array.size  # total number of elements in the array
@@ -15,7 +15,7 @@ array.data  # buffer containing the array elements
 Unless explicitly specified `np.array` tries to infer a good data type for the array that it creates.  
 The data type is stored in a special dtype object.
 
-```py linenums="1"
+```py
 var = np.array(sequence)  # creates array
 var = np.asarray(sequence)  # convert input to array
 var = np.ndarray(*sequence)  # creates multidimensional array
@@ -33,7 +33,7 @@ var = np.linspace(start, stop, num_of_elements)  # step of elements calculated b
 
 ## DATA TYPES FOR NDARRAYS
 
-```py linenums="1"
+```py
 var = array.astype(np.dtype)  # copy of the array, cast to a specified type
 # return TypeError if casting fails
 ```
@@ -72,7 +72,7 @@ array_1 `/` array_2 --> element-wise division (`[1, 2, 3] / [3, 2, 1] = [0.33, 1
 
 ## SHAPE MANIPULATION
 
-```py linenums="1"
+```py
 np.reshape(array, new_shape)  # changes the shape of the array
 np.ravel(array)  #  returns the array flattened
 array.resize(shape)  # modifies the array itself
@@ -84,7 +84,7 @@ np.swapaxes(array, first_axis, second_axis)  # interchange two axes of an array
 
 ## JOINING ARRAYS
 
-```py linenums="1"
+```py
 np.vstack((array1, array2))   # takes tuple, vertical stack of arrays (column wise)
 np.hstack((array1, array2))  # takes a tuple, horizontal stack of arrays (row wise)
 np.dstack((array1, array2)) # takes a tuple, depth wise stack of arrays (3rd dimension)
@@ -94,7 +94,7 @@ np.concatenate((array1, array2, ...), axis) # joins a sequence of arrays along a
 
 ## SPLITTING ARRAYS
 
-```py linenums="1"
+```py
 np.split(array, indices)  # splits an array into equall7 long sub-arrays (indices is int), if not possible raises error
 np.vsplit(array, indices)  # splits an array equally into sub-arrays vertically (row wise) if not possible raises error
 np.hsplit(array, indices)  # splits an array equally into sub-arrays horizontally (column wise) if not possible raises error
@@ -104,7 +104,7 @@ np.array_split(array, indices) # splits an array into sub-arrays, arrays can be
 
 ## VIEW()
 
-```py linenums="1"
+```py
 var = array.view()  # creates a new array that looks at the same data
 # slicing returns a view
 # view shapes are separated but assignment changes all arrays
@@ -112,7 +112,7 @@ var = array.view()  # creates a new array that looks at the same data
 
 ## COPY()
 
-```py linenums="1"
+```py
 var = array.copy()  # creates a deep copy of the array
 ```
 
@@ -136,7 +136,7 @@ iteration on first index, use .flat() to iterate over each element
 
 Functions that performs element-wise operations (vectorization).
 
-```py linenums="1"
+```py
 np.abs(array)  # vectorized abs(), return element absolute value
 np.fabs(array)  # faster abs() for non-complex values
 np.sqrt(array)  # vectorized square root (x^0.5)
@@ -193,7 +193,7 @@ np.logical_xor(x_array, y_array)  # vectorized x ^ y
 
 ## CONDITIONAL LOGIC AS ARRAY OPERATIONS
 
-```py linenums="1"
+```py
 np.where(condition, x, y)  # return x if condition == True, y otherwise
 ```
 
@@ -202,7 +202,7 @@ np.where(condition, x, y)  # return x if condition == True, y otherwise
 `np.method(array, args)` or `array.method(args)`.  
 Boolean values are coerced to 1 (`True`) and 0 (`False`).
 
-```py linenums="1"
+```py
 np.sum(array, axis=None)  # sum of array elements over a given axis
 np.median(array, axis=None)  # median along the specified axis
 np.mean(array, axis=None)  # arithmetic mean along the specified axis
@@ -220,21 +220,21 @@ np.cumprod(array, axis=None)  # cumulative sum of the elements along a given axi
 
 ## METHODS FOR BOOLEAN ARRAYS
 
-```py linenums="1"
+```py
 np.all(array, axis=None)  # test whether all array elements along a given axis evaluate to True
 np.any(array, axis=None)  # test whether any array element along a given axis evaluates to True
 ```
 
 ## SORTING
 
-```py linenums="1"
+```py
 array.sort(axis=-1)  # sort an array in-place (axis = None applies on flattened array)
 np.sort(array, axis=-1)  # return a sorted copy of an array (axis = None applies on flattened array)
 ```
 
 ## SET LOGIC
 
-```py linenums="1"
+```py
 np.unique(array)  # sorted unique elements of an array
 np.intersect1d(x, y)  # sorted common elements in x and y
 np.union1d(x, y)  # sorte union of elements
@@ -245,7 +245,7 @@ np.setxor1d()  # Set symmetric differences; elements that are in either of the a
 
 ## FILE I/O WITH ARRAYS
 
-```py linenums="1"
+```py
 np.save(file, array)  # save array to binary file in .npy format
 np.savez(file, *array) # save several arrays into a single file in uncompressed .npz format
 np.savez_compressed(file, *args, *kwargs)  # save several arrays into a single file in compressed .npz format
@@ -266,7 +266,7 @@ np.loadtxt(file, dtype=float, comments="#", delimiter=None)
 
 ## LINEAR ALGEBRA
 
-```py linenums="1"
+```py
 np.diag(array, k=0)  # extract a diagonal or construct a diagonal array
 # K: {int} -- k>0 diagonals above main diagonal, k<0 diagonals below main diagonal (main diagonal k = 0)
 
@@ -290,7 +290,7 @@ np.linalg.lstsq(A, B)  # return the least-squares solution to a linear matrix eq
 
 ## RANDOM NUMBER GENERATION
 
-```py linenums="1"
+```py
 np.random.seed()
 np.random.rand()
 np.random.randn()

docs/languages/python/libs/pandas.md

@@ -2,7 +2,7 @@
 
 ## Basic Pandas Imports
 
-```py linenums="1"
+```py
 import numpy as np
 import pandas as pd
 from pandas import Series, DataFrame
@@ -13,7 +13,7 @@ from pandas import Series, DataFrame
 1-dimensional labelled array, axis label referred as INDEX.  
 Index can contain repetitions.
 
-```py linenums="1"
+```py
 s = Series(data, index=index, name='name')
 # DATA: {python dict, ndarray, scalar value}
 # NAME: {string}
@@ -22,7 +22,7 @@ s = Series(dict)  # Series created from python dict, dict keys become index valu
 
 ### INDEXING / SELECTION / SLICING
 
-```py linenums="1"
+```py
 s['index']  # selection by index label
 s[condition]  # return slice selected by condition
 s[ : ]  # slice endpoint included
@@ -34,7 +34,7 @@ s[condition] = *value  # modify slice by condition
 
 Missing data appears as NaN (Not a Number).
 
-```py linenums="1"
+```py
 pd.isnull(array)  # return a Series index-bool indicating which indexes don't have data
 pd.notnull(array)  # return a Series index-bool indicating which indexes have data
 array.isnull()
@@ -43,7 +43,7 @@ array.notnull()
 
 ### SERIES ATTRIBUTES
 
-```py linenums="1"
+```py
 s.values  # NumPy representation of Series
 s.index  # index object of Series
 s.name = "Series name"  # renames Series object
@@ -52,7 +52,7 @@ s.index.name = "index name"  # renames index
 
 ### SERIES METHODS
 
-```py linenums="1"
+```py
 pd.Series.isin(self, values)  #  boolean Series showing whether elements in Series matches elements in values exactly
 
 # Conform Series to new index, new object produced unless the new index is equivalent to current one and copy=False
@@ -80,7 +80,7 @@ pd.Series.value_counts(self, normalize=False, sort=True, ascending=False, bins=N
 2-dimensional labeled data structure with columns of potentially different types.
 Index and columns can contain repetitions.
 
-```py linenums="1"
+```py
 df = DataFrame(data, index=row_labels, columns=column_labels)
 # DATA: {list, dict (of lists), nested dicts, series, dict of 1D ndarray, 2D ndarray, DataFrame}
 # INDEX: {list of row_labels}
@@ -112,7 +112,7 @@ del df[col]  # delete column
 
 ### DATAFRAME ATTRIBUTES
 
-```py linenums="1"
+```py
 df.index  # row labels
 df.columns  # column labels
 df.values  # NumPy representation of DataFrame
@@ -123,7 +123,7 @@ df.T # transpose
 
 ### DATAFRAME METHODS
 
-```py linenums="1"
+```py
 pd.DataFrame.isin(self , values)  # boolean DataFrame showing whether elements in DataFrame matches elements in values exactly
 
 # Conform DataFrame to new index, new object produced unless the new index is equivalent to current one and copy=False
@@ -146,7 +146,7 @@ Holds axis labels and metadata, immutable.
 
 ### INDEX TYPES
 
-```py linenums="1"
+```py
 pd.Index  # immutable ordered ndarray, sliceable. stores axis labels
 pd.Int64Index  # special case of Index with purely integer labels
 pd.MultiIndex  # multi-level (hierarchical) index object for pandas objects
@@ -156,7 +156,7 @@ pd.DatetimeIndex  # nanosecond timestamps (uses Numpy datetime64)
 
 ### INDEX ATTRIBUTERS
 
-```py linenums="1"
+```py
 pd.Index.is_monotonic_increasing  # Return True if the index is monotonic increasing (only equal or increasing) values
 pd.Index.is_monotonic_decreasing  # Return True if the index is monotonic decreasing (only equal or decreasing) values
 pd.Index.is_unique  # Return True if the index has unique values.
@@ -165,7 +165,7 @@ pd.Index.hasnans  # Return True if the index has NaNs
 
 ### INDEX METHODS
 
-```py linenums="1"
+```py
 pd.Index.append(self, other)  # append a collection of Index options together
 
 pd.Index.difference(self, other, sort=None)  # set difference of two Index objects
@@ -197,7 +197,7 @@ Missing values propagate in arithmetic computations (NaN `<operator>` value = Na
 
 ### ADDITION
 
-```py linenums="1"
+```py
 self + other
 pd.Series.add(self, other, fill_value=None)  # add(), supports substitution of NaNs
 pd,Series.radd(self, other, fill_value=None)  # radd(), supports substitution of NaNs
@@ -210,7 +210,7 @@ pd.DataFrame.radd(self, other, axis=columns, fill_value=None)  # radd(), support
 
 ### SUBTRACTION
 
-```py linenums="1"
+```py
 self - other
 pd.Series.sub(self, other, fill_value=None)  # sub(), supports substitution of NaNs
 pd.Series.radd(self, other, fill_value=None)  # radd(), supports substitution of NaNs
@@ -223,7 +223,7 @@ pd.DataFrame.rsub(self, other, axis=columns, fill_value=None)  # rsub(), support
 
 ### MULTIPLICATION
 
-```py linenums="1"
+```py
 self * other
 pd.Series.mul(self, other, fill_value=None)  # mul(), supports substitution of NaNs
 pd.Series.rmul(self, other, fill_value=None)  # rmul(), supports substitution of NaNs
@@ -236,7 +236,7 @@ pd.DataFrame.rmul(self, other, axis=columns, fill_value=None)  # rmul(), support
 
 ### DIVISION (float division)
 
-```py linenums="1"
+```py
 self / other
 pd.Series.div(self, other, fill_value=None)  # div(), supports substitution of NaNs
 pd.Series.rdiv(self, other, fill_value=None)  # rdiv(), supports substitution of NaNs
@@ -253,7 +253,7 @@ pd.DataFrame.rtruediv(self, other, axis=columns, fill_value=None)  # rtruediv(),
 
 ### FLOOR DIVISION
 
-```py linenums="1"
+```py
 self // other
 pd.Series.floordiv(self, other, fill_value=None)  # floordiv(), supports substitution of NaNs
 pd.Series.rfloordiv(self, other, fill_value=None)  # rfloordiv(), supports substitution of NaNs
@@ -266,7 +266,7 @@ pd.DataFrame.rfloordiv(self, other, axis=columns, fill_value=None)  # rfloordiv(
 
 ### MODULO
 
-```py linenums="1"
+```py
 self % other
 pd.Series.mod(self, other, fill_value=None)  # mod(), supports substitution of NaNs
 pd.Series.rmod(self, other, fill_value=None)  # rmod(), supports substitution of NaNs
@@ -279,7 +279,7 @@ pd.DataFrame.rmod(self, other, axis=columns, fill_value=None)  # rmod(), support
 
 ### POWER
 
-```py linenums="1"
+```py
 other ** self
 pd.Series.pow(self, other, fill_value=None)  # pow(), supports substitution of NaNs
 pd.Series.rpow(self, other, fill_value=None)  # rpow(), supports substitution of NaNs
@@ -296,7 +296,7 @@ pd.DataFrame.rpow(self, other, axis=columns, fill_value=None)  # rpow(), support
 
 NumPy ufuncs work fine with pandas objects.
 
-```py linenums="1"
+```py
 pd.DataFrame.applymap(self, func)  # apply function element-wise
 
 pd.DataFrame.apply(self, func, axis=0, args=())  # apply a function along an axis of a DataFrame
@@ -324,7 +324,7 @@ pd.DataFrame.sort_values(self, axis=0, ascending=True, **kwargs)  # sort object
 
 ### COUNT
 
-```py linenums="1"
+```py
 pd.Series.count(self)  # return number of non-NA/null observations in the Series
 pd.DataFrame.count(self, numeric_only=False)  # count non-NA cells for each column or row
 # NUMERIC_ONLY: {bool} -- Include only float, int or boolean data -- DEFAULT False
@@ -334,7 +334,7 @@ pd.DataFrame.count(self, numeric_only=False)  # count non-NA cells for each colu
 
 Generate descriptive statistics summarizing central tendency, dispersion and shape of dataset's distribution (exclude NaN).
 
-```py linenums="1"
+```py
 pd.Series.describe(self, percentiles=None, include=None, exclude=None)
 pd.DataFrame.describe(self, percentiles=None, include=None, exclude=None)
 # PERCENTILES: {list-like of numbers} -- percentiles to include in output,between 0 and 1 -- DEFAULT [.25, .5, .75]
@@ -344,7 +344,7 @@ pd.DataFrame.describe(self, percentiles=None, include=None, exclude=None)
 
 ### MAX - MIN
 
-```py linenums="1"
+```py
 pd.Series.max(self, skipna=None, numeric_only=None)  # maximum of the values for the requested axis
 pd.Series.min(self, skipna=None, numeric_only=None)  # minimum of the values for the requested axis
 pd.DataFrame.max(self, axis=None, skipna=None, numeric_only=None)  # maximum of the values for the requested axis
@@ -355,7 +355,7 @@ pd.DataFrame.min(self, axis=None, skipna=None, numeric_only=None)  # minimum of
 
 ### IDXMAX - IDXMIN
 
-```py linenums="1"
+```py
 pd.Series.idxmax(self, skipna=True)  # row label of the maximum value
 pd.Series.idxmin(self, skipna=True)  # row label of the minimum value
 pd.DataFrame.idxmax(self, axis=0, skipna=True)  #  Return index of first occurrence of maximum over requested axis
@@ -366,7 +366,7 @@ pd.DataFrame.idxmin(self, axis=0, skipna=True)  #  Return index of first occurre
 
 ### QUANTILE
 
-```py linenums="1"
+```py
 pd.Series.quantile(self, q=0.5, interpolation='linear')  # return values at the given quantile
 pd.DataFrame.quantile(self, q=0.5, axis=0, numeric_only=True, interpolation='linear') # return values at the given quantile over requested axis
 # Q: {flaot, array} -- value between 0 <= q <= 1, the quantile(s) to compute -- DEFAULT 0.5 (50%)
@@ -376,7 +376,7 @@ pd.DataFrame.quantile(self, q=0.5, axis=0, numeric_only=True, interpolation='lin
 
 ### SUM
 
-```py linenums="1"
+```py
 pd.Series.sum(self, skipna=None, numeric_only=None, min_count=0)  # sum of the values
 pd.DataFrame.sum(self, axis=None, skipna=None, numeric_only=None, min_count=0)  # sum of the values for the requested axis
 # AXIS: {0, 1, index, columns} -- axis for the function to be applied on
@@ -387,7 +387,7 @@ pd.DataFrame.sum(self, axis=None, skipna=None, numeric_only=None, min_count=0)
 
 ### MEAN
 
-```py linenums="1"
+```py
 pd.Series.mean(self, skipna=None, numeric_only=None)   # mean of the values
 pd.DataFrame.mean(self, axis=None, skipna=None, numeric_only=None)  # mean of the values for the requested axis
 # AXIS: {0, 1, index, columns} -- axis for the function to be applied on
@@ -397,7 +397,7 @@ pd.DataFrame.mean(self, axis=None, skipna=None, numeric_only=None)  # mean of th
 
 ### MEDIAN
 
-```py linenums="1"
+```py
 pd.Series.median(self, skipna=None, numeric_only=None)  # median of the values
 pd.DataFrame.median(self, axis=None, skipna=None, numeric_only=None)  # median of the values for the requested axis
 # AXIS: {0, 1, index, columns} -- axis for the function to be applied on
@@ -407,7 +407,7 @@ pd.DataFrame.median(self, axis=None, skipna=None, numeric_only=None)  # median o
 
 ### MAD (mean absolute deviation)
 
-```py linenums="1"
+```py
 pd.Series.mad(self, skipna=None)  # mean absolute deviation
 pd.DataFrame.mad(self, axis=None, skipna=None)  # mean absolute deviation of the values for the requested axis
 # AXIS: {0, 1, index, columns} -- axis for the function to be applied on
@@ -416,7 +416,7 @@ pd.DataFrame.mad(self, axis=None, skipna=None)  # mean absolute deviation of the
 
 ### VAR (variance)
 
-```py linenums="1"
+```py
 pd.Series.var(self, skipna=None, numeric_only=None)  # unbiased variance
 pd.DataFrame.var(self, axis=None, skipna=None, ddof=1, numeric_only=None)  #  unbiased variance over requested axis
 # AXIS: {0, 1, index, columns} -- axis for the function to be applied on
@@ -427,7 +427,7 @@ pd.DataFrame.var(self, axis=None, skipna=None, ddof=1, numeric_only=None)  #  un
 
 ### STD (standard deviation)
 
-```py linenums="1"
+```py
 pd.Series.std(self, skipna=None, ddof=1, numeric_only=None)  # sample standard deviation
 pd.Dataframe.std(self, axis=None, skipna=None, ddof=1, numeric_only=None)  # sample standard deviation over requested axis
 # AXIS: {0, 1, index, columns} -- axis for the function to be applied on
@@ -438,7 +438,7 @@ pd.Dataframe.std(self, axis=None, skipna=None, ddof=1, numeric_only=None)  # sam
 
 ### SKEW
 
-```py linenums="1"
+```py
 pd.Series.skew(self, skipna=None, numeric_only=None)  # unbiased skew Normalized bt N-1
 pd.DataFrame.skew(self, axis=None, skipna=None, numeric_only=None)  #  unbiased skew over requested axis Normalized by N-1
 # AXIS: {0, 1, index, columns} -- axis for the function to be applied on
@@ -450,7 +450,7 @@ pd.DataFrame.skew(self, axis=None, skipna=None, numeric_only=None)  #  unbiased
 
 Unbiased kurtosis over requested axis using Fisher's definition of kurtosis (kurtosis of normal == 0.0). Normalized by N-1.
 
-```py linenums="1"
+```py
 pd.Series.kurt(self, skipna=None, numeric_only=None)
 pd.Dataframe.kurt(self, axis=None, skipna=None, numeric_only=None)
 # AXIS: {0, 1, index, columns} -- axis for the function to be applied on
@@ -460,7 +460,7 @@ pd.Dataframe.kurt(self, axis=None, skipna=None, numeric_only=None)
 
 ### CUMSUM (cumulative sum)
 
-```py linenums="1"
+```py
 pd.Series.cumsum(self, skipna=True)  # cumulative sum
 pd.Dataframe.cumsum(self, axis=None, skipna=True)  # cumulative sum over requested axis
 # AXIS: {0, 1, index, columns} -- axis for the function to be applied on
@@ -469,7 +469,7 @@ pd.Dataframe.cumsum(self, axis=None, skipna=True)  # cumulative sum over request
 
 ### CUMMAX - CUMMIN (cumulative maximum - minimum)
 
-```py linenums="1"
+```py
 pd.Series.cummax(self, skipna=True)  # cumulative maximum
 pd.Series.cummin(self, skipna=True)  # cumulative minimum
 pd.Dataframe.cummax(self, axis=None, skipna=True)  # cumulative maximum over requested axis
@@ -480,7 +480,7 @@ pd.Dataframe.cummin(self, axis=None, skipna=True)  # cumulative minimum over req
 
 ### CUMPROD (cumulative product)
 
-```py linenums="1"
+```py
 pd.Series.cumprod(self, skipna=True)  # cumulative product
 pd.Dataframe.cumprod(self, axis=None, skipna=True)  # cumulative product over requested axis
 # AXIS: {0, 1, index, columns} -- axis for the function to be applied on
@@ -492,7 +492,7 @@ pd.Dataframe.cumprod(self, axis=None, skipna=True)  # cumulative product over re
 Calculates the difference of a DataFrame element compared with another element in the DataFrame.  
 (default is the element in the same column of the previous row)
 
-```py linenums="1"
+```py
 pd.Series.diff(self, periods=1)
 pd.DataFrame.diff(self, periods=1, axis=0)
 # PERIODS: {int} -- Periods to shift for calculating difference, accepts negative values -- DEFAULT 1
@@ -503,7 +503,7 @@ pd.DataFrame.diff(self, periods=1, axis=0)
 
 Percentage change between the current and a prior element.
 
-```py linenums="1"
+```py
 pd.Series.Pct_change(self, periods=1, fill_method='pad', limit=None, freq=None)
 pd.Dataframe.pct_change(self, periods=1, fill_method='pad', limit=None)
 # PERIODS:{int} -- periods to shift for forming percent change
@@ -515,7 +515,7 @@ pd.Dataframe.pct_change(self, periods=1, fill_method='pad', limit=None)
 
 ### FILTERING OUT MISSING DATA
 
-```py linenums="1"
+```py
 pd.Series.dropna(self, inplace=False)  # return a new Series with missing values removed
 pd.DataFrame.dropna(axis=0, how='any', tresh=None, subset=None, inplace=False)  # return a new DataFrame with missing values removed
 # AXIS: {tuple, list} -- tuple or list to drop on multiple axes. only a single axis is allowed
@@ -529,7 +529,7 @@ pd.DataFrame.dropna(axis=0, how='any', tresh=None, subset=None, inplace=False)
 
 Fill NA/NaN values using the specified method.
 
-```py linenums="1"
+```py
 pd.Series.fillna(self, value=None, method=None, inplace=False, limit=None)
 pd.DataFrame.fillna(self, value=None, method=None, axis=None, inplace=False, limit=None)
 # VALUE: {scalar, dict, Series, DataFrame} -- value to use to fill holes, dict/Series/DataFrame specifying which value to use for each index or column
@@ -546,7 +546,7 @@ In lower dimensional data structures like Series (1d) and DataFrame (2d).
 
 ### MULTIIINDEX CREATION
 
-```py linenums="1"
+```py
 pd.MultiIndex.from_arrays(*arrays, names=None)  # convert arrays to MultiIndex
 pd.MultiIndex.from_tuples(*arrays, names=None)  # convert tuples to MultiIndex
 pd.MultiIndex.from_frame(df, names=None)  # convert DataFrame to MultiIndex
@@ -559,7 +559,7 @@ pd.DataFrame(*arrays)  # Index constructor makes MultiINdex from DataFrame
 
 Vector of label values for requested level, equal to the length of the index.
 
-```py linenums="1"
+```py
 pd.MultiIndex.get_level_values(self, level)
 ```
 
@@ -567,7 +567,7 @@ pd.MultiIndex.get_level_values(self, level)
 
 Partial selection "drops" levels of the hierarchical index in the result  in a completely analogous way to selecting a column in a regular DataFrame.
 
-```py linenums="1"
+```py
 pd.Series.xs(self, key, axis=0, level=None, drop_level=True)  # cross-section from Series
 pd.DataFrame.xs(self, key, axis=0, level=None, drop_level=True)  #  cross-section from DataFrame
 # KEY: {label, tuple of label} -- label contained in the index, or partially in a MultiIndex
@@ -580,7 +580,7 @@ pd.DataFrame.xs(self, key, axis=0, level=None, drop_level=True)  #  cross-sectio
 
 Multi index keys take the form of tuples.
 
-```py linenums="1"
+```py
 df.loc[('lvl_1', 'lvl_2', ...)]  # selection of single row
 df.loc[('idx_lvl_1', 'idx_lvl_2', ...), ('col_lvl_1', 'col_lvl_2', ...)]  # selection of single value
 
@@ -591,7 +591,7 @@ df.loc[('idx_lvl_1', 'idx_lvl_2') : ('idx_lvl_1', 'idx_lvl_2')]  # slice of rows
 
 ### REORDERING AND SORTING LEVELS
 
-```py linenums="1"
+```py
 pd.MultiIndex.swaplevel(self, i=-2, j=-1)  # swap level i with level j
 pd.Series.swaplevel(self, i=-2, j=-1) # swap levels i and j in a MultiIndex
 pd.DataFrame.swaplevel(self, i=-2, j=-1, axis=0) # swap levels i and j in a MultiIndex on a partivular axis
@@ -604,7 +604,7 @@ pd.MultiIndex.sortlevel(self, level=0, ascending=True, sort_remaining=True)  # s
 
 ## DATA LOADING, STORAGE FILE FORMATS
 
-```py linenums="1"
+```py
 pd.read_fwf(filepath, colspecs='infer', widths=None, infer_nrows=100)  # read a table of fixed-width formatted lines into DataFrame
 # FILEPATH: {str, path object} -- any valid string path is acceptable, could be a URL. Valid URLs: http, ftp, s3, and file
 # COLSPECS: {list of tuple (int, int), 'infer'} -- list of tuples giving extents of fixed-width fields of each line as half-open intervals { [from, to) }

docs/languages/python/libs/requests.md

@@ -4,7 +4,7 @@
 
 Get or retrieve data from specified resource
 
-```py linenums="1"
+```py
 response = requests.get('URL')    # returns response object
 
 # PAYLOAD -> valuable information of response
@@ -18,7 +18,7 @@ The response message consists of:
 - empty line
 - optional message body
 
-```text linenums="1"
+```text
 1xx -> INFORMATIONAL RESPONSE
 2xx -> SUCCESS
     200 OK -> request successful
@@ -28,7 +28,7 @@ The response message consists of:
 5xx -> SERVER ERRORS
 ```
 
-```py linenums="1"
+```py
 # raise exception HTTPError for error status codes
 response.raise_for_status()
 
@@ -41,7 +41,7 @@ response.headers    # response headers (dict)
 
 ### QUERY STRING PARAMETERS
 
-```py linenums="1"
+```py
 response = requests.get('URL', params={'q':'query'})
 response = requests.get('URL', params=[('q', 'query')])
 response = requests.get('URL', params=b'q=query')
@@ -49,7 +49,7 @@ response = requests.get('URL', params=b'q=query')
 
 ### REQUEST HEADERS
 
-```py linenums="1"
+```py
 response = requests.get(
     'URL',
     params={'q': 'query'},
@@ -61,7 +61,7 @@ response = requests.get(
 
 ### DATA INPUT
 
-```py linenums="1"
+```py
 # requests that entity enclosed be stored as a new subordinate of the web resource identified by the URI
 requests.post('URL', data={'key':'value'})
 # requests that the enclosed entity be stored under the supplied URI
@@ -78,13 +78,13 @@ requests.options('URL')
 
 ### SENDING JSON DATA
 
-```py linenums="1"
+```py
 requests.post('URL', json={'key': 'value'})
 ```
 
 ### INSPECTING THE REQUEST
 
-```py linenums="1"
+```py
 # requests lib prepares the requests before sending it
 response = requests.post('URL', data={'key':'value'})
 response.request.something    # inspect request field
@@ -92,7 +92,7 @@ response.request.something    # inspect request field
 
 ## AUTHENTICATION
 
-```py linenums="1"
+```py
 requests.get('URL', auth=('username', 'password'))    # use implicit HTTP Basic Authorization
 
 # explicit HTTP Basic Authorization and other
@@ -103,7 +103,7 @@ requests.get('URL', auth=HTTPBasicAuth('username', getpass()))
 
 ### PERSONALIZED AUTH
 
-```py linenums="1"
+```py
 from requests.auth import AuthBase
 class TokenAuth(AuthBase):
     "custom authentication scheme"
@@ -121,7 +121,7 @@ requests.get('URL', auth=TokenAuth('1234abcde-token'))
 
 ### DISABLING SSL VERIFICATION
 
-```py linenums="1"
+```py
 requests.get('URL', verify=False)
 ```
 
@@ -129,14 +129,14 @@ requests.get('URL', verify=False)
 
 ### REQUEST TIMEOUT
 
-```py linenums="1"
+```py
 # raise Timeout exception if request times out
 requests.get('URL', timeout=(connection_timeout, read_timeout))
 ```
 
 ### MAX RETRIES
 
-```py linenums="1"
+```py
 from requests.adapters import HTTPAdapter
 URL_adapter = HTTPAdapter(max_retries = int)
 session = requests.Session()

docs/languages/python/libs/seaborn.md

@@ -2,7 +2,7 @@
 
 ## Basic Imports For Seaborn
 
-```python linenums="1"
+```python
 import numpy as np
 import pandas as pd
 import matplotlib.pyplot as plt
@@ -15,7 +15,7 @@ sns.set(style='darkgrid')
 
 ## REPLOT (relationship)
 
-```python linenums="1"
+```python
 sns.replot(x='name_in_data', y='name_in_data', hue='point_color', size='point_size', style='point_shape', data=data)
 # HUE, SIZE and STYLE: {name in data} -- used to differentiate points, a sort-of 3rd dimension
 # hue behaves differently if the data is categorical or numerical, numerical uses a color gradient
@@ -38,7 +38,7 @@ sns.scatterplot()  # underlying axis-level function of replot()
 
 Using semantics in lineplot will determine the aggregation of data.
 
-```python linenums="1"
+```python
 sns.replot(ci=None, sort=bool, kind='line')
 sns.lineplot()  # underlying axis-level function of replot()
 ```
@@ -47,7 +47,7 @@ sns.lineplot()  # underlying axis-level function of replot()
 
 Categorical: divided into discrete groups.
 
-```python linenums="1"
+```python
 sns.catplot(x='name_in_data', y='name_in_data', data=data)
 # HUE: {name in data} -- used to differenziate points, a sort-of 3rd dimension
 # COL, ROW: {name in data}  -- categorical variables that will determine the grid of plots
@@ -68,7 +68,7 @@ sns.stripplot()
 
 Adjusts the points along the categorical axis preventing overlap.
 
-```py linenums="1"
+```py
 sns.catplot(kind='swarm')
 sns.swarmplot()
 # SIZE: {float}  -- Diameter of the markers, in points
@@ -84,7 +84,7 @@ sns.boxplot()
 
 Combines a boxplot with the kernel density estimation procedure.
 
-```py linenums="1"
+```py
 sns.catplot(kind='violin')
 sns.violonplot()
 ```
@@ -94,7 +94,7 @@ sns.violonplot()
 Plot similar to boxplot but optimized for showing more information about the shape of the distribution.  
 It is best suited for larger datasets.
 
-```py linenums="1"
+```py
 sns.catplot(kind='boxen')
 sns.boxenplot()
 ```
@@ -103,7 +103,7 @@ sns.boxenplot()
 
 Show point estimates and confidence intervals using scatter plot glyphs.
 
-```py linenums="1"
+```py
 sns.catplot(kind='point')
 sns.pointplot()
 # CI: {float, sd} -- size of confidence intervals to draw around estimated values, sd -> standard deviation
@@ -120,7 +120,7 @@ sns.pointplot()
 
 Show point estimates and confidence intervals as rectangular bars.
 
-```py linenums="1"
+```py
 sns.catplot(kind='bar')
 sns.barplot()
 # CI: {float, sd} -- size of confidence intervals to draw around estimated values, sd -> standard deviation
@@ -134,7 +134,7 @@ sns.barplot()
 
 Show the counts of observations in each categorical bin using bars.
 
-```py linenums="1"
+```py
 sns.catplot(kind='count')
 sns.countplot()
 # DODGE: {bool} -- whether elements should be shifted along the categorical axis if hue is used
@@ -146,7 +146,7 @@ sns.countplot()
 
 Flexibly plot a univariate distribution of observations
 
-```py linenums="1"
+```py
 # A: {series, 1d-array, list}
 sns.distplot(a=data)
 # BINS: {None, arg for matplotlib hist()} -- specification of hist bins, or None to use Freedman-Diaconis rule
@@ -160,7 +160,7 @@ sns.distplot(a=data)
 
 Plot datapoints in an array as sticks on an axis.
 
-```py linenums="1"
+```py
 # A: {vector} -- 1D array of observations
 sns.rugplot(a=data) # -> axes obj with plot on it
 # HEIGHT: {scalar} --  height of ticks as proportion of the axis
@@ -172,7 +172,7 @@ sns.rugplot(a=data) # -> axes obj with plot on it
 
 Fit and plot a univariate or bivariate kernel density estimate.
 
-```py linenums="1"
+```py
 # DATA: {1D array-like} -- input data
 sns.kdeplot(data=data)
 # DATA2 {1D array-like} -- second input data. if present, a bivariate KDE will be estimated.
@@ -185,7 +185,7 @@ sns.kdeplot(data=data)
 
 Draw a plot of two variables with bivariate and univariate graphs.
 
-```py linenums="1"
+```py
 # X, Y: {string, vector} -- data or names of variables in data
 sns.jointplot(x=data, y=data)
 # DATA:{pandas DataFrame} -- DataFrame when x and y are variable names
@@ -203,7 +203,7 @@ sns.jointplot(x=data, y=data)
 
 Plot pairwise relationships in a dataset.
 
-```py linenums="1"
+```py
 # DATA: {pandas DataFrame} -- tidy (long-form) dataframe where each column is a variable and each row is an observation
 sns.pairplot(data=pd.DataFrame)
 # HUE: {string (variable name)} -- variable in data to map plot aspects to different colors

docs/languages/python/libs/tkinter.md

@@ -2,7 +2,7 @@
 
 ## Standard Imports
 
-```py linenums="1"
+```py
 from tkinter import *  # import Python Tk Binding
 from tkinter import ttk  # import Themed Widgets
 ```
@@ -19,7 +19,7 @@ geometry managers determine size and oder widget drawing properties
 event loop receives events from the OS  
 customizable events provide a callback as a widget configuration
 
-```py linenums="1"
+```py
 widget.bind('event', function)  # method to capture any event and than execute an arbitrary piece of code (generally a function or lambda)
 ```
 
@@ -29,7 +29,7 @@ VIRTUAL EVENT --> hig level event generated by widget (listed in widget docs)
 
 Widgets are objects and all things on screen. All widgets are children of a window.
 
-```py linenums="1"
+```py
 widget_name = tk_object(parent_window)  # widget is inserted into widget hierarchy
 ```
 
@@ -37,7 +37,7 @@ widget_name = tk_object(parent_window)  # widget is inserted into widget hierarc
 
 Displays a single rectangle, used as container for other widgets
 
-```py linenums="1"
+```py
 frame = ttk.Frame(parent, width=None, height=None, borderwidth=num:int)
 # BORDERWIDTH: sets frame border width (default: 0)
 # width, height MUST be specified if frame is empty, otherwise determined by parent geometry manager
@@ -47,7 +47,7 @@ frame = ttk.Frame(parent, width=None, height=None, borderwidth=num:int)
 
 Extra space inside widget (margin).
 
-```py linenums="1"
+```py
 frame['padding'] = num  # same padding for every border
 frame['padding'] = (horizontal, vertical)  # set horizontal THEN vertical padding
 frame['padding'] = (left, top, right, bottom)  # set left, top, right, bottom padding
@@ -60,13 +60,13 @@ frame['relief'] = border_style
 
 Display text or image without interactivity.
 
-```py linenums="1"
+```py
 label = ttk.Label(parent, text='label text')
 ```
 
 ### DEFINING UPDATING LABEL
 
-```py linenums="1"
+```py
 var = StringVar()  # variable containing text, watches for changes. Use get, set methods to interact with the value
 label['textvariable'] = var  # attach var to label (only of type StringVar)
 var.set("new text label")  #  change label text
@@ -74,14 +74,14 @@ var.set("new text label")  #  change label text
 
 ### DISPLAY IMAGES (2 steps)
 
-```py linenums="1"
+```py
 image = PhotoImage(file='filename')  # create image object
 label['image'] = image  # use image config
 ```
 
 ### DISPLAY IMAGE AND-OR TEXT
 
-```py linenums="1"
+```py
 label['compound'] = value
 ```
 
@@ -97,20 +97,20 @@ Compound value:
 
 Specifies edge or corner that the label is attached.
 
-```py linenums="1"
+```py
 label['anchor'] = compass_direction  #compass_direction: n, ne, e, se, s, sw, w, nw, center
 ```
 
 ### MULTI-LINE TEXT WRAP
 
-```py linenums="1"
+```py
 # use \n for multi line text
 label['wraplength'] = size  # max line length
 ```
 
 ### CONTROL TEXT JUSTIFICATION
 
-```py linenums="1"
+```py
 label['justify'] = value  #value: left, center, right
 
 label['relief'] = label_style
@@ -120,7 +120,7 @@ label['background'] = color  # color passed with name or HEX RGB codes
 
 ### FONT STYLE (use with caution)
 
-```py linenums="1"
+```py
 # used outside style option
 label['font'] = font
 ```
@@ -141,19 +141,19 @@ Fonts:
 
 Press to perform some action
 
-```py linenums="1"
+```py
 button = ttk.Button(parent, text='button_text', command=action_performed)
 ```
 
 ### TEXT or IMAGE
 
-```py linenums="1"
+```py
 button['text/textvariable'], button['image'], button['compound']
 ```
 
 ### BUTTON INVOCATION
 
-```py linenums="1"
+```py
 button.invoke()  # button activation in the program
 ```
 
@@ -161,7 +161,7 @@ button.invoke()  # button activation in the program
 
 Activate or deactivate the widget.
 
-```py linenums="1"
+```py
 button.state(['disabled'])            # set the disabled flag, disabling the button
 button.state(['!disabled'])           # clear the disabled flag
 button.instate(['disabled'])          # return true if the button is disabled, else false
@@ -174,7 +174,7 @@ button.instate(['!disabled'], cmd)  # execute 'cmd' if the button is not disable
 
 Button with binary value of some kind (e.g a toggle) and also invokes a command callback
 
-```py linenums="1"
+```py
 checkbutton_var = TkVarType
 check = ttk.Checkbutton(parent, text='button text', command=action_performed, variable=checkbutton_var, onvalue=value_on, offvalue=value_off)
 ```
@@ -189,7 +189,7 @@ checkbutton won't set the linked variable (MUST be done in the program)
 
 ### CONFIG OPTIONS
 
-```py linenums="1"
+```py
 check['text/textvariable']
 check['image']
 check['compound']
@@ -201,7 +201,7 @@ check.instate(['flag'])
 
 Multiple-choice selection (good if options are few).
 
-```py linenums="1"
+```py
 #RADIOBUTTON CREATION (usually as a set)
 radio_var = TkVarType
 radio_1 = ttk.Radiobutton(parent, text='button text', variable=radio_var, value=button_1_value)
@@ -221,7 +221,7 @@ radio.instate(['flag'])
 
 Single line text field accepting a string.
 
-```py linenums="1"
+```py
 entry_var = StringVar()
 entry = ttk.Entry(parent, textvariable=entry_var, width=char_num, show=symbol)
 # SHOW: replaces the entry test with symbol, used for password
@@ -230,7 +230,7 @@ entry = ttk.Entry(parent, textvariable=entry_var, width=char_num, show=symbol)
 
 ### CHANGE ENTRY VALUE
 
-```py linenums="1"
+```py
 entry.get()  # returns entry value
 entry.delete(start, 'end')  # delete between two indices, 0-based
 entry.insert(index, 'text value')  # insert new text at a given index
@@ -238,7 +238,7 @@ entry.insert(index, 'text value')  # insert new text at a given index
 
 ### ENTRY CONFIG OPTIONS
 
-```py linenums="1"
+```py
 radio.state(['flag'])
 radio.instate(['flag'])
 ```
@@ -247,7 +247,7 @@ radio.instate(['flag'])
 
 Drop-down list of available options.
 
-```py linenums="1"
+```py
 combobox_var = StringVar()
 combo = ttk.Combobox(parent, textvariable=combobox_var)
 combobox.get()  # return combobox current value
@@ -259,7 +259,7 @@ combobox.bind('<<ComboboxSelected>>', function)
 
 ### PREDEFINED VALUES
 
-```py linenums="1"
+```py
 combobox['values'] = (value_1, value_2, ...)  # provides a list of choose-able values
 combobox.state(['readonly'])  # restricts choose-able values to those provided with 'values' config option
 # SUGGESTION: call selection clear method on value change (on ComboboxSelected event) to avoid visual oddities
@@ -269,7 +269,7 @@ combobox.state(['readonly'])  # restricts choose-able values to those provided w
 
 Display list of single-line items, allows browsing and multiple selection (part og Tk classic, missing in themed Tk widgets).
 
-```py linenums="1"
+```py
 lstbx = Listbox(parent, height=num, listvariable=item_list:list)
 # listvariable links a variable (MUST BE a list) to the listbox, each element is a item of the listbox
 # manipulation of the list changes the listbox
@@ -277,7 +277,7 @@ lstbx = Listbox(parent, height=num, listvariable=item_list:list)
 
 ### SELECTING ITEMS
 
-```py linenums="1"
+```py
 lstbx['selectmode'] = mode  # MODE: browse (single selection), extended (multiple selection)
 lstbx.curselection()  # returns list of indices of selected items
 # on selection change: generate event <ListboxSelect>
@@ -288,7 +288,7 @@ lstbx.curselection()  # returns list of indices of selected items
 
 ## SCROLLBAR
 
-```py linenums="1"
+```py
 scroll = ttk.Scrollbar(parent, orient=direction, command=widget.view)
 # ORIENT: VERTICAL, HORIZONTAL
 # WIDGET.VIEW: .xview, .yview
@@ -301,7 +301,7 @@ widget.configure(yscrollcommand=scroll.set)
 
 Box in right bottom of widget, allows resize.
 
-```py linenums="1"
+```py
 ttk.Sizegrip(parent).grid(column=999, row=999, sticky=(S, E))
 ```
 
@@ -309,7 +309,7 @@ ttk.Sizegrip(parent).grid(column=999, row=999, sticky=(S, E))
 
 Area accepting multiple line of text.
 
-```py linenums="1"
+```py
 txt = Text(parent, width=num:int, height=num:int, wrap=flag)  # width is character num, height is row num
 # FLAG: none (no wrapping), char (wrap at every character), word (wrap at word boundaries)
 txt['state'] = flag  # FLAG: disabled, normal
@@ -323,7 +323,7 @@ txt.delete(start, end)  # delete range of text
 
 Feedback about progress of lenghty operation.
 
-```py linenums="1"
+```py
 progbar = ttk.Progressbar(parent, orient=direction, length=num:int, value=num, maximum=num:float mode=mode)
 # DIRECTION: VERTICAL, HORIZONTAL
 # MODE: determinate (relative progress of completion), indeterminate (no estimate of completion)
@@ -334,13 +334,13 @@ progbar = ttk.Progressbar(parent, orient=direction, length=num:int, value=num, m
 
 ### DETERMINATE PROGRESS
 
-```py linenums="1"
+```py
 progbar.step(amount)  # increment value of given amount (DEFAULT: 1.0)
 ```
 
 ### INDETERMINATE PROGRESS
 
-```py linenums="1"
+```py
 progbar.start()  # starts progressbar
 progbar.stop()  #stoops progressbar
 ```
@@ -349,7 +349,7 @@ progbar.stop()  #stoops progressbar
 
 Provide a numeric value through direct manipulation.
 
-```py linenums="1"
+```py
 scale = ttk.Scale(parent, orient=DIR, length=num:int, from_=num:float, to=num:float, command=cmd)
 # COMMAND: calls cmd at every scale change, appends current value to func call
 scale['value']  # set or read current value
@@ -361,7 +361,7 @@ scale.get()  # get current value
 
 Choose numbers. The spinbox choses item from a list, arrows permit cycling lits items.
 
-```py linenums="1"
+```py
 spinval = StringVar()
 spin = Spinbox(parent, from_=num, to=num, textvariable=spinval, increment=num, value=lst, wrap=boolean)
 # INCREMENT specifies increment\decrement by arrow button
@@ -402,7 +402,7 @@ A single value for the option puts the same padding on both left and right (or t
 while a two-value list lets you put different amounts on left and right (or top and bottom).  
 To add padding around an entire row or column, the "columnconfigure" and "rowconfigure" methods accept a "pad" option.  
 
-```py linenums="1"
+```py
 widget.grid(column=num, row=num, columnspan=num, rowspan=num, sticky=(), padx=num, pady=num)  # sticky: N, S, E, W
 widget.columnconfigure(pad=num, weight=num)
 widget.rowconfigure(pad=num, weight=num)
@@ -419,7 +419,7 @@ widget.grid_remove(slaves)  # takes a list of slaves, removes slaves from grid (
 
 ### CREATING TOPLEVEL WINDOW
 
-```py linenums="1"
+```py
 tlw = Toplevel(parent)  # parent of root window, no need to grid it
 
 window.destroy()
@@ -429,7 +429,7 @@ window.destroy()
 
 ### CHANGING BEHAVIOR AND STYLE
 
-```py linenums="1"
+```py
 # WINDOW TILE
 window.title()  # returns title of the window
 window.title('new title')  # sets title
@@ -469,7 +469,7 @@ window.deiconify()  # deiconifies window
 
 ### STANDARD DIALOGS
 
-```py linenums="1"
+```py
 # SLEETING FILE AND DIRECTORIES
 # on Windows and Mac invokes underlying OS dialogs directly
 from tkinter import filedialog
@@ -507,7 +507,7 @@ POSSIBLE ALERT/CONFIRMATION RETURN VALUES:
 
 ## SEPARATOR
 
-```py linenums="1"
+```py
 # horizontal or vertical line between groups of widgets
 separator = ttk.Separator(parent, orient=direction)
 # DIRECTION: horizontal, vertical
@@ -532,7 +532,7 @@ pw.forget(position)  # remove widget from pane
 
 Allows switching between multiple pages
 
-```py linenums="1"
+```py
 nb = ttk.Notebook(parent)
 f1 = ttk.Frame(parent, ...)  # child of notebook
 f2 = ttk.Frame(parent, ...)
@@ -555,7 +555,7 @@ nb.tab(tabid, option=value)   # change tab option
 
 Creation of personalized fonts
 
-```py linenums="1"
+```py
 from tkinter import font
 font_name = font.Font(family='font_family', size=num, weight='bold/normal', slant='roman/italic', underline=boolean, overstrike=boolean)
 # FAMILY: Courier, Times, Helvetica (support guaranteed)
@@ -573,7 +573,7 @@ label['image'] = imgobj
 
 #### IMAGES W/ Pillow
 
-```py linenums="1"
+```py
 from PIL import ImageTk, Image
 myimg = ImageTk.PhotoImage(Image.open('filename'))
 ```

docs/languages/python/modules/argparse.md

@@ -2,7 +2,7 @@
 
 ## Creating a parser
 
-```py linenums="1"
+```py
 import argparse
 
 parser = argparse.ArgumentParser(description="description", allow_abbrev=True)
@@ -25,7 +25,7 @@ parser = argparse.ArgumentParser(description="description", allow_abbrev=True)
 
 ## [Adding Arguments](https://docs.python.org/3/library/argparse.html#the-add-argument-method)
 
-```py linenums="1"
+```py
 ArgumentParser.add_argument("name_or_flags", nargs="...", action="...")
 ```
 
@@ -47,7 +47,7 @@ ArgumentParser.add_argument("name_or_flags", nargs="...", action="...")
 
 `store`: This just stores the argument's value. This is the default action.
 
-```py linenums="1"
+```py
 >>> parser = argparse.ArgumentParser()
 >>> parser.add_argument('--foo')
 >>> parser.parse_args('--foo 1'.split())
@@ -56,7 +56,7 @@ Namespace(foo='1')
 
 `store_const`: This stores the value specified by the const keyword argument. The `store_const` action is most commonly used with optional arguments that specify some sort of flag.
 
-```py linenums="1"
+```py
 >>> parser = argparse.ArgumentParser()
 >>> parser.add_argument('--foo', action='store_const', const=42)
 >>> parser.parse_args(['--foo'])
@@ -65,7 +65,7 @@ Namespace(foo=42)
 
 `store_true` and `store_false`: These are special cases of `store_const` used for storing the values True and False respectively. In addition, they create default values of False and True respectively.
 
-```py linenums="1"
+```py
 >>> parser = argparse.ArgumentParser()
 >>> parser.add_argument('--foo', action='store_true')
 >>> parser.add_argument('--bar', action='store_false')
@@ -76,7 +76,7 @@ Namespace(foo=True, bar=False, baz=True)
 
 `append`: This stores a list, and appends each argument value to the list. This is useful to allow an option to be specified multiple times. Example usage:
 
-```py linenums="1"
+```py
 >>> parser = argparse.ArgumentParser()
 >>> parser.add_argument('--foo', action='append')
 >>> parser.parse_args('--foo 1 --foo 2'.split())
@@ -85,7 +85,7 @@ Namespace(foo=['1', '2'])
 
 `append_const`: This stores a list, and appends the value specified by the const keyword argument to the list. (Note that the const keyword argument defaults to None.) The `append_const` action is typically useful when multiple arguments need to store constants to the same list. For example:
 
-```py linenums="1"
+```py
 >>> parser = argparse.ArgumentParser()
 >>> parser.add_argument('--str', dest='types', action='append_const', const=str)
 >>> parser.add_argument('--int', dest='types', action='append_const', const=int)
@@ -96,7 +96,7 @@ Namespace(types=[<class 'str'>, <class 'int'>])
 `count`: This counts the number of times a keyword argument occurs. For example, this is useful for increasing verbosity levels:
 **Note**: the default will be None unless explicitly set to 0.
 
-```py linenums="1"
+```py
 >>> parser = argparse.ArgumentParser()
 >>> parser.add_argument('--verbose', '-v', action='count', default=0)
 >>> parser.parse_args(['-vvv'])
@@ -107,7 +107,7 @@ Namespace(verbose=3)
 
 `version`: This expects a version= keyword argument in the add_argument() call, and prints version information and exits when invoked:
 
-```py linenums="1"
+```py
 >>> import argparse
 >>> parser = argparse.ArgumentParser(prog='PROG')
 >>> parser.add_argument('--version', action='version', version='%(prog)s 2.0')
@@ -117,7 +117,7 @@ PROG 2.0
 
 `extend`: This stores a list, and extends each argument value to the list. Example usage:
 
-```py linenums="1"
+```py
 >>> parser = argparse.ArgumentParser()
 >>> parser.add_argument("--foo", action="extend", nargs="+", type=str)
 >>> parser.parse_args(["--foo", "f1", "--foo", "f2", "f3", "f4"])
@@ -133,7 +133,7 @@ The `nargs` keyword argument associates a different number of command-line argum
 
 `N` (an integer): N arguments from the command line will be gathered together into a list.
 
-```py linenums="1"
+```py
 >>> parser = argparse.ArgumentParser()
 >>> parser.add_argument('--foo', nargs=2)
 >>> parser.add_argument('bar', nargs=1)
@@ -147,7 +147,7 @@ Namespace(bar=['c'], foo=['a', 'b'])
 
 For optional arguments, there is an additional case: the option string is present but not followed by a command-line argument. In this case the value from const will be produced.
 
-```py linenums="1"
+```py
 >>> parser = argparse.ArgumentParser()
 >>> parser.add_argument('--foo', nargs='?', const='c', default='d')
 >>> parser.add_argument('bar', nargs='?', default='d')
@@ -161,7 +161,7 @@ Namespace(bar='d', foo='d')
 
 `*`: All command-line arguments present are gathered into a list. Note that it generally doesn't make much sense to have more than one positional argument with `nargs='*'`, but multiple optional arguments with `nargs='*'` is possible.
 
-```py linenums="1"
+```py
 >>> parser = argparse.ArgumentParser()
 >>> parser.add_argument('--foo', nargs='*')
 >>> parser.add_argument('--bar', nargs='*')
@@ -172,7 +172,7 @@ Namespace(bar=['1', '2'], baz=['a', 'b'], foo=['x', 'y'])
 
 `+`: All command-line args present are gathered into a list. Additionally, an error message will be generated if there wasn't at least one command-line argument present.
 
-```py linenums="1"
+```py
 >>> parser = argparse.ArgumentParser(prog='PROG')
 >>> parser.add_argument('foo', nargs='+')
 >>> parser.parse_args(['a', 'b'])
@@ -184,7 +184,7 @@ PROG: error: the following arguments are required: foo
 
 `argparse.REMAINDER`: All the remaining command-line arguments are gathered into a list. This is commonly useful for command line utilities that dispatch to other command line utilities.
 
-```py linenums="1"
+```py
 >>> parser = argparse.ArgumentParser(prog='PROG')
 >>> parser.add_argument('--foo')
 >>> parser.add_argument('command')
@@ -195,7 +195,7 @@ Namespace(args=['--arg1', 'XX', 'ZZ'], command='cmd', foo='B')
 
 ## Parsing Arguments
 
-```py linenums="1"
+```py
 # Convert argument strings to objects and assign them as attributes of the namespace. Return the populated namespace.
 ArgumentParser.parse_args(args=None, namespace=None)
 

docs/languages/python/modules/ftplib.md

@@ -2,7 +2,7 @@
 
 ## FTP CLASSES
 
-```py linenums="1"
+```py
 ftplib.FTP(host="", user="", password="", acct="")
 # if HOST => connect(host)
 # if USER => login(user, password, acct)
@@ -13,7 +13,7 @@ ftplib.FTP_TLS(host="", user="", password="", acct="")
 
 ## EXCEPTIONS
 
-```py linenums="1"
+```py
 ftplib.error_reply  # unexpected error from server
 ftplib.error_temp  # temporary error (response codes 400-499)
 ftplib.error_perm  # permanent error (response codes 500-599)
@@ -23,7 +23,7 @@ ftplib.all_errors  # tuple of all exceptions
 
 ## FTP OBJECTS
 
-```py linenums="1"
+```py
 # method on text files: -lines
 # method on binary files: -binary
 

docs/languages/python/modules/json.md

@@ -34,7 +34,7 @@ WHITESPACE can be inserted between any pair of tokens.
 
 ## Usage
 
-```python linenums="1"
+```python
 
 # serialize obj as JSON formatted stream to fp
 json.dump(obj, fp, cls=None, indent=None, separators=None, sort_keys=False)
@@ -90,7 +90,7 @@ Conversions (Python -> Json):
 
 ## Extending JSONEncoder (Example)
 
-```python linenums="1"
+```python
 import json
 
 class ComplexEncoder(json.JSONEncoder):
@@ -103,7 +103,7 @@ class ComplexEncoder(json.JSONEncoder):
 
 ## Retrieving Data from json dict
 
-```python linenums="1"
+```python
 data = json.loads(json)
 data["key"]  # retrieve the value associated with the key
 data["outer key"]["nested key"]  # nested key value retrieval

docs/languages/python/modules/logging.md

@@ -2,7 +2,7 @@
 
 ## Configuration
 
-```python linenums="1"
+```python
 # basic configuration for the logging system
 logging.basicConfig(filename="relpath", level=logging.LOG_LEVEL, format=f"message format", **kwargs)  
 # DATEFMT: Use the specified date/time format, as accepted by time.strftime().
@@ -76,7 +76,7 @@ Log Levels (Low To High):
 - error: `40`
 - critical: `50`
 
-```python linenums="1"
+```python
 logging.debug(msg)  # Logs a message with level DEBUG on the root logger
 logging.info(msg)  # Logs a message with level INFO on the root logger
 logging.warning(msg)  # Logs a message with level WARNING on the root logger

docs/languages/python/modules/shutil.md

@@ -2,7 +2,7 @@
 
 High-level file operations
 
-```python linenums="1"
+```python
 # copy file src to fil dst, return dst in most efficient way
 shutil.copyfile(src, dst)
 # dst MUST be complete target name

docs/languages/python/modules/smtplib.md

@@ -1,6 +1,6 @@
 # SMTPlib Module
 
-```python linenums="1"
+```python
 import smtplib
 
 # SMTP instance that encapsulates a SMTP connection

docs/languages/python/modules/socket.md

@@ -9,7 +9,7 @@ In this context, sockets are assumed to be associated with a specific socket add
 
 ## Socket Creation & Connection
 
-```python linenums="1"
+```python
 import socket
 
 # socket over the internet, socket is a stream of data
@@ -21,7 +21,7 @@ socket.close()  # close connection
 
 ## Making HTTP Requests
 
-```python linenums="1"
+```python
 import socket
 HTTP_Method = "GET http://url/resource HTTP/version\n\n".encode()  # set HTTP request (encoded string from UTF-8 to bytes)
 socket.send(HTTP_Method)   # make HTTP request

docs/languages/python/modules/sqlite.md

@@ -4,14 +4,14 @@
 
 To use the module, you must first create a Connection object that represents the database.
 
-```python linenums="1"
+```python
 import sqlite3
 connection = sqlite3.connect("file.db")
 ```
 
 Once you have a `Connection`, you can create a `Cursor` object and call its `execute()` method to perform SQL commands.
 
-```python linenums="1"
+```python
 cursor = connection.cursor()
 
 cursor.execute(sql)
@@ -31,7 +31,7 @@ it makes your program vulnerable to an [SQL injection attack](https://en.wikiped
 
 Put `?` as a placeholder wherever you want to use a value, and then provide a _tuple of values_ as the second argument to the cursor's `execute()` method.
 
-```python linenums="1"
+```python
 # Never do this -- insecure!
 c.execute("SELECT * FROM stocks WHERE symbol = value")
 
@@ -50,7 +50,7 @@ c.executemany('INSERT INTO stocks VALUES (?,?,?,?,?)', purchases)
 
 ### Writing Operations to Disk
 
-```python linenums="1"
+```python
 cursor = connection.cursor()
 cursor.execute("SQL")
 connection.commit()
@@ -58,7 +58,7 @@ connection.commit()
 
 ### Multiple SQL Instructions
 
-```python linenums="1"
+```python
 connection = sqlite3.connect("file.db")
 cur = con.cursor()
 cur.executescript("""
@@ -73,7 +73,7 @@ con.close()
 
 ### Retrieving Records
 
-```python linenums="1"
+```python
 # Fetches the next row of a query result set, returning a single sequence.
 # Returns None when no more data is available.
 cursor.fetchone()  

docs/languages/python/modules/time-datetime.md

@@ -2,7 +2,7 @@
 
 ## Time
 
-```py linenums="1"
+```py
 # epoch: elapsed time in seconds (in UNIX starts from 01-010-1970)
 import time # UNIX time
 variable = time.time () # returns the time (in seconds) elapsed since 01-01-1970
@@ -42,7 +42,7 @@ var = time.perf_counter () # returns the current running time
 
 ## Datetime
 
-```py linenums="1"
+```py
 import datetime
 today = datetime.date.today () # returns current date
 today = datetime.datetime.today () # returns the current date and time

docs/languages/python/modules/unittest.md

@@ -1,6 +1,6 @@
 # Unittest Module
 
-```py linenums="1"
+```py
 import unittest
 import module_under_test
 

docs/languages/python/python.md

@@ -8,7 +8,7 @@ Class -> PascalCase
 Method, Function -> snake_case  
 Variable -> snake_case
 
-```py linenums="1"
+```py
 # standard comment
 '''multiline comment'''
 """DOCSTRING"""
@@ -38,7 +38,7 @@ string.whitespace
 
 ### Assignment Operation
 
-```py linenums="1"
+```py
 """instructions to the right of = executed before instructions to the left of ="""
 variable = expression # the type of the variable is dynamically decided by python based on the content
 var_1, var_2 = value1, value2 # parallel assignment
@@ -56,7 +56,7 @@ x = a or b # If bool (a) returns False, then x is assigned the value of b
 
 ### Expression Assignment
 
-```py linenums="1"
+```py
 (var: = expression) # assign an expression to a variable to avoid repeating the expression
 ```
 
@@ -67,7 +67,7 @@ x = a or b # If bool (a) returns False, then x is assigned the value of b
 
 ### On Screen Output
 
-```py linenums="1"
+```py
 print() # print blank line and wrap
 print('string' * n) # print string n times
 print('string1 \ n string2') # wrap with \ n
@@ -131,7 +131,7 @@ Format: `[[fill]align] [sign] [#] [width] [grouping] [.precision] [type]`
 
 ### Keyboard Input
 
-```py linenums="1"
+```py
 # input always returns a STRING
 s = input() # input request without message
 s = input('Prompt') # request input
@@ -144,7 +144,7 @@ list = [int(x) for x in input('prompt'). split('separator')]
 
 ## Numeric Types
 
-```py linenums="1"
+```py
 a = 77
 b = 1_000_000 # underscore can be used to separate groups of digits
 c = -69
@@ -189,7 +189,7 @@ It is worth checking if the difference between the numbers is small enough.
 
 ## Strings
 
-```py linenums="1"
+```py
 
 string = 'string content' # assignment and creation of string variable
 string = '''multi
@@ -266,7 +266,7 @@ string.center(width, 'char') # stretch the string with char to width
 
 ## Lists
 
-```py linenums="1"
+```py
 list = [9, 11, 'WTC', -5.6, True] # lists can contain data of different types
 
 list[3] # indexing
@@ -339,7 +339,7 @@ var = [(exp_1, exp_2) for item_1 in seq_1 for item_2 in seq_2] # -> [(..., ...),
 
 ## Tuple
 
-```py linenums="1"
+```py
 # TUPLES CANNOT BE MODIFIED
 tuple = (69, 420, 69, 'abc') # tuple assignment
 tuple = (44,) # single element tuples need a comma
@@ -370,7 +370,7 @@ var_1, * body, var_2, var_3 = sequence # var_1 = seq [0], body = seq [1: -2], va
 
 ## Set
 
-```py linenums="1"
+```py
 # SETS MAY NOT CONTAIN REPEATED ELEMENTS (THEY ARE OMITTED)
 # THE ORDER DOES NOT MATTER (NO SLICING, INDEXING, REPETITION, ...)
 set = {10, 20, 30, 'abc', 20}
@@ -426,7 +426,7 @@ var[i, ...] # -> shortcut for var [i,:,:,:,]
 
 ## Bytes e Bytearray
 
-```py linenums="1"
+```py
 # THE BYTES CANNOT BE MODIFIED OR INDEXED
 # THE BYTEARRAYS CAN BE MODIFIED AND INDEXED
 # YOU CANNOT DO REPETITION AND SLICING ON BYTE OR BYTEARRAY
@@ -453,7 +453,7 @@ Unicode Literals:
 - `\U00000041` --> 'A'
 - `\x41` --> 'A'
 
-```py linenums="1"
+```py
 # ENCODING
 # transform string into literal byte
 # UnicodeEncodeError on error
@@ -494,7 +494,7 @@ def fold_equal (str_1, str_2):
 
 ## Memoryview
 
-```py linenums="1"
+```py
 # memoryview objects allow python to access the data inside the object
 # without copy if it supports the buffer protocol
 v = memoryview(object) # create a memoryview with reference to object
@@ -538,7 +538,7 @@ v.shape # tuple of integers indicating the shape of the memoryview
 
 ## Dictionaries
 
-```py linenums="1"
+```py
 # SET OF KEY-VALUE PAIRS
 d = {1: 'Alex', 2: 'Bob', 3: 'Carl'}
 d = dict (one = 'Alex', two = 'Bob', three = 'Carl')
@@ -677,7 +677,7 @@ built-in objects considered *false*:
 
 ### `if-else`
 
-```py linenums="1"
+```py
 if (condition):
     # code here
 elif (condition):
@@ -688,7 +688,7 @@ else:
 
 ### Context Manager
 
-```py linenums="1"
+```py
 with resource as target:
      # code here
 
@@ -709,7 +709,7 @@ contextmanager.__exit__(self, exc_type, exc_value, traceback)
 
 ### `while`
 
-```py linenums="1"
+```py
 while(condition):
      # code here
 else:
@@ -720,7 +720,7 @@ else:
 
 ### `for`
 
-```py linenums="1"
+```py
 for index in sequence: # sequence can be a list, set, tuple, etc ..
      # code here
 else:
@@ -742,21 +742,21 @@ for key, value in dict.items ():
 
 ### `range`
 
-```py linenums="1"
+```py
 range(start, end, step) # generate sequence num integers (does not include num stops) with possible step
 list(range(start, end, step)) # return sequence of integers in a list
 ```
 
 ### `enumerate`
 
-```py linenums="1"
+```py
 enumerate(iterable) # iterable of item & index pairs
 list(enumerate(iterable)) # returns list of tuples [(1, iterable [0]), (2, iterable [1]), (3, iterable [2])]
 ```
 
 ### `zip`
 
-```py linenums="1"
+```py
 list_1 = [1, 2, 3, 4, 5]
 list_2 = ['a', 'b', 'c', 'd', 'e']
 
@@ -766,7 +766,7 @@ list(zip(list_1, list_2)) # returns list of tuples by merging list [(list_1 [0],
 
 ### `shuffle` & `randint`
 
-```py linenums="1"
+```py
 from random import shuffle, randint
 shuffle(iterable) # shuffle the list
 randint(start, end) # returns a random integer between start and end
@@ -774,7 +774,7 @@ randint(start, end) # returns a random integer between start and end
 
 ### `in`
 
-```py linenums="1"
+```py
 item in iterable # check for the presence of item in iterable (returns True or False)
 ```
 
@@ -782,7 +782,7 @@ item in iterable # check for the presence of item in iterable (returns True or F
 
 ### Function Definition
 
-```py linenums="1"
+```py
 def function_name (parameters):
      "" "DOCSTRING" ""
      # code here
@@ -795,14 +795,14 @@ def function_name (parameters):
 - parameters between `/` and `*` can be *positional* or *keyworded*
 - parameters after `*` can only be *keyworded*
   
-```py linenums="1"
+```py
 def func (a, b, /, c, d, *, e, f):
      # code here
 ```
 
 ### Docstring Style
 
-```py linenums="1"
+```py
 """function description
 
 Args:
@@ -823,14 +823,14 @@ Raises:
 
 When used in combination `*args` always goes before`**kwargs` (in def function and in function call)
 
-```py linenums="1"
+```py
 def func(*args, **kwargs):
     # code here
 ```
 
 ### Function with default parameters
 
-```py linenums="1"
+```py
 def function(parameter1 = value1, parameter2 = value3): # default values in case of omitted use of arguments in the call
      # code here
      return expression
@@ -840,7 +840,7 @@ function(parameter2 = value2, parameter1 = value1) # arguments passed with keywo
 
 ### Global And Local Variables
 
-```py linenums="1"
+```py
 # global scope
 
 def external_func():
@@ -859,7 +859,7 @@ def external_func():
 
 `Note`: variables declared inside a function are not usable outside
 
-```py linenums="1"
+```py
 def function():
      # global statement makes a variable global
      # actions on global variable within the function also have an effect outside
@@ -887,7 +887,7 @@ Operation `iter()`:
 
 ### `next()` & `iter()`
 
-```py linenums="1"
+```py
 next(iterable) # next item of the iterable or error StopIteration
 
 iter(object) # get an iterator from an object
@@ -900,7 +900,7 @@ iter(callable_obj, sentinel)
 
 Used to generate a sequence of values to be used once (they are not stored)
 
-```py linenums="1"
+```py
 def custom_generator(parameters):
      while condition: # or for loop
          yield variable # returns the value without terminating the function, values passed to the caller without storing in a variable
@@ -912,7 +912,7 @@ for item in custom_generator(parameters):
 
 ### Termination Generator And Exception Handling
 
-```py linenums="1"
+```py
 # raise exception at the suspension point and return generator value
 # if the generator terminates without returning values it raises StopIteration
 # if an exception is not handled it is propagated to the caller
@@ -926,7 +926,7 @@ generator.close()
 
 ### Generator Comprehensions
 
-```py linenums="1"
+```py
 # zero-length sequence (instantaneously generated values)
 var = (for expression iterable in sequence if condition)
 # EDUCATION ENUMERATE ()
@@ -937,7 +937,7 @@ enumerate(sequence) # -> enumerate object
 
 ## Coroutines
 
-```py linenums="1"
+```py
 def simple_coroutine():
     """coroutine defined as a generator: yield in block"""
 
@@ -1020,7 +1020,7 @@ The main function of `yield from` is to open a bidirectional channel between the
   - If this call results in an exception, it is propagated to the delegating generator.
   - Otherwise, `GeneratorExit` is raised in the delegating generator
 
-```py linenums="1"
+```py
 def sub_gen():
      sent_input = yield
      # result of sub_gen() returned to delegating_gen()
@@ -1040,7 +1040,7 @@ def client():
 
 Possible use within functions. Useful for replacing functions if the logic is simple.
 
-```py linenums="1"
+```py
 var = lambda argument_list: <expression>
 ```
 
@@ -1048,7 +1048,7 @@ var = lambda argument_list: <expression>
 
 ### Class Definition
 
-```py linenums="1"
+```py
 class Class:
 
     static_var = expression
@@ -1077,7 +1077,7 @@ class Class:
 
 ### Setter & Getter with `@Property`
 
-```py linenums="1"
+```py
 class Class:
      def __init__(self, parameter):
          self.__parameter = parameter
@@ -1102,7 +1102,7 @@ The `__slots__` attribute implements the **Flyweight Design Pattern**: it saves
 
 ### Inner Classes
 
-```py linenums="1"
+```py
 class Class:
      def __init__(self, parameters):
          ...
@@ -1122,7 +1122,7 @@ object_2 = Class.InnerClass(arguments) # inner class created as object of the 'e
 
 Special methods are defined by the use of double underscores; they allow the use of specific functions (possibly adapted) on the objects defined by the class.
 
-```py linenums="1"
+```py
 class Class():
 
      def __init__(self, parameters):
@@ -1148,7 +1148,7 @@ del object # delete object
 
 **Note**: if the operator cannot be applied, returns `NotImplemented`
 
-```py linenums="1"
+```py
 # arithmetic operators
 __add__(self, other)         # +
 __sub__(self, other)         # -
@@ -1309,7 +1309,7 @@ however, if the underlying method is linear (as it would be with a linked list),
 
 ### Inheritance
 
-```py linenums="1"
+```py
 class Parent ():
     def __init __ (self, parameters):
         ...
@@ -1350,7 +1350,7 @@ class Child(Parent): # parent class in brackets to inherit properties
 
 **Note**: python does not support method overloading
 
-```py linenums="1"
+```py
 # DUCKTYPING
 # Working with objects regardless of their type, as long as they implement certain protocols
 
@@ -1396,7 +1396,7 @@ Virtual subclasses are used to include third-party classes as subclasses of a cl
 
 The `@Class.register` or `Class.register(subclass)` decorators are used to mark subclasses.
 
-```py linenums="1"
+```py
 from abc import abstractmethod, ABC
 
 class Abstract(ABC): # abstract class MUST INHERIT from parent class ABC
@@ -1429,7 +1429,7 @@ class Child(Abstract):
 
 ## Exception Handling
 
-```py linenums="1"
+```py
 # CHECK ASERATIONS
 assert condition, 'error message' # if the assertion is false show an error message
 
@@ -1490,7 +1490,7 @@ Open binary file mode:
 
 **Note**: Linux and MacOSX use `UTF-8` everywhere while windows uses `cp1252`, `cp850`,`mbcs`, `UTF-8`. Don't rely on default encoding and use **explicitly** `UTF-8`.
 
-```py linenums="1"
+```py
 object = open('filename', mode = 'r', encoding = 'utf-8') # encoding MUST BE utf-8 for compatibility
 # filename can be the absolute path to the file location (default: file created in the source code folder)
 # double slash to avoid \ escaping
@@ -1525,7 +1525,7 @@ else:
 **SHALLOW COPY**: copies the "container" and references to the content
 **DEEP COPY**: copies the "container" and contents (no reference)
 
-```py linenums="1"
+```py
 copy (x) # returns shallow copy of xor
 deepcopy (x) # returns shallow copy of x
 ```

docs/languages/rust/cargo.md

@@ -2,7 +2,7 @@
 
 ## Creating a project
 
-```ps1 linenums="1"
+```ps1
 cargo new project_name  # creates project folder and basic files
 cargo new --vcs=git project_name  # init project as git repo
 ```
@@ -11,7 +11,7 @@ cargo new --vcs=git project_name  # init project as git repo
 
 Inside the project directory:
 
-```ps1 linenums="1"
+```ps1
 cargo build  # build project and download eventual needed dependencies
 cargo build --release  # build project for release (build + optimisations)
 cargo run  # executes the built executable
@@ -22,7 +22,7 @@ cargo check  # verifies buildability without producing an executable
 
 In `Cargo.toml`:
 
-```toml linenums="1"
+```toml
 [dependencies]
 crate_name = "<version_number>"
 ```
@@ -70,7 +70,7 @@ A path can take two forms:
 
 Both absolute and relative paths are followed by one or more identifiers separated by double colons (`::`).
 
-```rs linenums="1"
+```rs
 module::function();  // rel path (same crate)
 super::function();;  // rel path starting in outer module (same crate)
 
@@ -88,7 +88,7 @@ The way privacy works in Rust is that all items (functions, methods, structs, en
 Items in a parent module can’t use the private items inside child modules, but items in child modules can use the items in their ancestor modules.  
 The reason is that child modules wrap and hide their implementation details, but the child modules can see the context in which they’re defined.
 
-```rs linenums="1"
+```rs
 mod module {
     fn func() {}
 }
@@ -109,7 +109,7 @@ In contrast, if an enum is made public, all of its variants are then public.
 
 ### `use`
 
-```rs linenums="1"
+```rs
 use <crate_name>::module;  // import module (abs path, other crate)
 use crate::module;  // import module (abs path, same crate)
 use self::module;  // import module (rel path, same crate)
@@ -125,7 +125,7 @@ module::function();  // use func w/ shorter path
 
 ## Separating into multiple files
 
-```txt linenums="1"
+```txt
 src
 |_main.rs  --> default executable file
 |_lib.rs  --> default library file
@@ -134,7 +134,7 @@ src
 |  |_submodule.rs --> submodule
 ```
 
-```rs linenums="1"
+```rs
 // main.rs
 mod module;  // declare module directory as a module
 

docs/languages/rust/rust.md

@@ -2,7 +2,7 @@
 
 ## Basics
 
-```rs linenums="1"
+```rs
 use <module>;  // bring a type into scope
 
 fn main() {  //program entry point
@@ -12,7 +12,7 @@ fn main() {  //program entry point
 
 ### Standard Output
 
-```rs linenums="1"
+```rs
 // macro (func have no "!")
 println!("Value: {}", value);  // {} is a placeholder for a value or variable
 println!("Values: {1}, {0}", value1, value2);  // use index to print values
@@ -30,7 +30,7 @@ print!();
 
 ### Standard Input
 
-```rs linenums="1"
+```rs
 use io;
 
 let mut buffer = String::new();
@@ -50,7 +50,7 @@ An associated function is implemented on a type rather than on a particular inst
 
 By default variables are *immutable*.
 
-```rs linenums="1"
+```rs
 let var1 = value;  // immutable var init
 let var2: Type = value;  // explicit type annotation
 
@@ -68,7 +68,7 @@ By using let, it's possible to perform a few transformations on a value but have
 The other difference between *mut* and *shadowing* is that because we're effectively creating a new variable when we use the let keyword again,  
 we can change the type of the value but reuse the same name.
 
-```rs linenums="1"
+```rs
 let x: u32 = 10;
 let x: i32 = 11;  // shadowing
 ```
@@ -88,7 +88,7 @@ let x: i32 = 11;  // shadowing
 
 #### Explicit Mathematical Operations (Integers)
 
-```rs linenums="1"
+```rs
 i32::MAX.checked_add(value);  // Option<i32> => None if overflow
 i32::MAX.wrapping_add(value);  // i32 => Wrap around
 i32::MAX.saturating_add(value);  //  i32 => MIN <= x <= MAX (Clamp)
@@ -164,7 +164,7 @@ Rust's `char` type is the language's most primitive alphabetic type.
 
 Rust's `char` type is four bytes in size and represents a Unicode Scalar Value: range from `U+0000` to `U+D7FF` and `U+E000` to `U+10FFFF` inclusive.
 
-```rs linenums="1"
+```rs
 let c: char = 'C';  // SINGLE QUOTES
 let c: char = '\u{261D}';  // Unicode Code Point U+261D
 let c: char = '\x2A';  // ASCII for *
@@ -179,7 +179,7 @@ std::char::from:digit(2, 10);  // Some(2)
 
 ### String Types
 
-```rs linenums="1"
+```rs
 let s = String::new();  // create empty string
 let s = String::from("string literal");  // construct string from literal
 
@@ -205,7 +205,7 @@ s.push_str(""); // appending string literals
 A tuple is a general way of grouping together a number of values with a variety of types into one compound type.  
 Tuples have a *fixed length*: once declared, they cannot grow or shrink in size.
 
-```rs linenums="1"
+```rs
 let tup: (i32, f64, u8) = (500, 6.4, 1);
 let tup = (500, 6.4, 1);
 
@@ -219,7 +219,7 @@ tup.0 = value;  // member access & update (mut be mutable)
 Every element of an array must have the *same type*. Arrays in Rust have a fixed length, like tuples.  
 An array isn't as flexible as the `vector` type, though. A vector is a similar collection type provided by the standard library that *is allowed to grow or shrink in size*.
 
-```rs linenums="1"
+```rs
 let array = [0, 1, 2, 3, 4];
 let array: [Type; length] = [...];
 let array: [value; length];  // repeat expression (same as python's [value] * length)
@@ -249,7 +249,7 @@ The reverse is not possible since the slice lacks some information about the Str
 
 > **Note**: When working with functions is easier to always expect a `&str` instead of a `&String`.
 
-```rs linenums="1"
+```rs
 let s = String::from("string literal");
 let slice: &str = &s[start..end];
 
@@ -262,7 +262,7 @@ sequence[..end]  // slice from start to end (excluded)
 
 ### Type Aliases
 
-```rs linenums="1"
+```rs
 type Alias = T;
 ```
 
@@ -275,7 +275,7 @@ The curly brackets tell the compiler where the function body begins and ends.
 
 Rust doesn't care where the functions are defined, only that they're defined somewhere.
 
-```rs linenums="1"
+```rs
   // parameters MUST have the Type annotation
 fn func(param: Type) {}
 
@@ -299,7 +299,7 @@ fn func() {
 
 ### if, else-if, else
 
-```rs linenums="1"
+```rs
 if condition {
     // [...]
 } else if condition {
@@ -311,13 +311,13 @@ if condition {
 
 ### let if
 
-```rs linenums="1"
+```rs
 let var = if condition { value } else { value };  // returned types must be the same
 ```
 
 ### if-let
 
-```rs linenums="1"
+```rs
 if let <pattern> = <expr> {
     <block1>
 } else {
@@ -333,14 +333,14 @@ match <expr> {
 
 ### loop
 
-```rs linenums="1"
+```rs
 // loop's forever if not explicitly stopped (return or break)
 loop { }
 ```
 
 ### while, while-let
 
-```rs linenums="1"
+```rs
 while condition { }
 
 while let <pattern> {}
@@ -348,7 +348,7 @@ while let <pattern> {}
 
 ### for
 
-```rs linenums="1"
+```rs
 for item in sequence.iter() { }
 for item in sequence.iter_mut() { }  // iterate over mutable items
 
@@ -362,7 +362,7 @@ for i in (start..end) { }
 
 ### Range
 
-```rs linenums="1"
+```rs
 ..  // RangeFull
 a ..  // RangeFrom { start: a }
 .. b  // RangeTo { end: b }
@@ -373,7 +373,7 @@ a ..= b  // RangeInclusive::new(a, b)
 
 ### `break` & `continue`
 
-```rs linenums="1"
+```rs
 while <condition> {
     // [...]
 
@@ -449,7 +449,7 @@ Cloning is an explicit action, `x.clone()`. The implementation of Clone can prov
 
 Rust won't allow to annotate a type with the `Copy` trait if the type, or any of its parts, has implemented the `Drop` trait.  
 
-```rs linenums="1"
+```rs
 let s = String::new()
 let t = s;  // MOVE, s is now uninitialized
 let u = t.clone();  // deep copy, t is still valid
@@ -462,7 +462,7 @@ let x = n;  // x holds a COPY of the VALUE of n
 
 The semantics for passing a value to a function are similar to those for assigning a value to a variable. Passing a variable to a function will move or copy, just as assignment does.
 
-```rs linenums="1"
+```rs
 fn main() {
     let s = String::from("hello");  // s comes into scope
 
@@ -487,7 +487,7 @@ fn makes_copy(some_integer: i32) { // some_integer comes into scope
 
 Returning values can also transfer ownership.
 
-```rs linenums="1"
+```rs
 fn main() {
     let s1 = gives_ownership();         // gives_ownership moves its return value into s1
 
@@ -537,7 +537,7 @@ A data race is similar to a race condition and happens when these three behavior
 - At least one of the pointers is being used to write to the data.  
 - There's no mechanism being used to synchronize access to the data.
 
-```rs linenums="1"
+```rs
 fn borrow(var: &Type) {  // &Type indicates that the var is a reference
     // here var cannot be modified
 } // when var goes out of scope it doesn't get dropped because the scope didn't own it
@@ -554,7 +554,7 @@ fn borrow2(var: &mut Type) {
 
 The `.` operator can **implicitly borrow or dereference** a reference
 
-```rs linenums="1"
+```rs
 let struct = Struct { field: /* [...] */ }
 let ref = &struct;
 
@@ -578,7 +578,7 @@ To define a struct enter the keyword struct and name the entire struct.
 A struct's name should describe the significance of the pieces of data being grouped together.  
 Then, inside curly brackets, define the names and types of the pieces of data, which we call *fields*.
 
-```rs linenums="1"
+```rs
 struct Struct {
     field: Type,
     ...
@@ -591,7 +591,7 @@ struct UnitStruct;  // no field, useful in generics
 
 To use a struct after defining it, create an instance of that struct by specifying concrete values for each of the fields.
 
-```rs linenums="1"
+```rs
 let mut var = Struct {
     field: value,
     ...
@@ -600,7 +600,7 @@ let mut var = Struct {
 
 ### Field Init Shorthand
 
-```rs linenums="1"
+```rs
 let mut var = Struct {
     field,  // shortened form since func param is named as the struct's field
     ...
@@ -613,7 +613,7 @@ var.field = value;  // member access
 
 ### Struct Update Syntax
 
-```rs linenums="1"
+```rs
 let struct1 = Struct {
     field1: value,
     field2: value,
@@ -631,7 +631,7 @@ let struct2 = Struct {
 Use Tuple Structs to create different types easily.  
 To define a **tuple struct**, start with the `struct` keyword and the struct name followed by the types in the tuple.
 
-```rs linenums="1"
+```rs
 struct Point(i32, i32, i32);
 struct Color(i32, i32, i32);
 
@@ -640,7 +640,7 @@ let origin = Point(0, 0, 0);
 
 ### Struct Printing
 
-```rs linenums="1"
+```rs
 #[derive(Debug)]  // inherit the debug trait
 struct Struct { }
 
@@ -650,7 +650,7 @@ println!("{:?}", s)  // debug output: { field: value, ... }
 
 ### Associated Functions & Type-Associated Functions (aka Methods)
 
-```rs linenums="1"
+```rs
 struct Struct { };
 impl Struct
 {
@@ -667,7 +667,7 @@ Struct::type_associated_function(arg);
 
 ### Associated Consts
 
-```rs linenums="1"
+```rs
 struct Struct {
     const ASSOCIATED_CONST: Type = <value>;
 }
@@ -680,7 +680,7 @@ Struct::ASSOCIATED_CONST;
 A Trait is a collection of methods representing a set of behaviours necessary to accomplish some task.  
 Traits can be used as generic types constraints and can be implemented by data types.
 
-```rs linenums="1"
+```rs
 trait Trait {
     fn method_signature(&self, param: Type) -> Type;
     fn method_signature(&self, param: Type) -> Type {
@@ -701,7 +701,7 @@ impl Trait for Struct {
 
 ### Fully Qualified Method Calls
 
-```rs linenums="1"
+```rs
 value.method();
 Type::method(value);
 Trait::method(value);
@@ -726,7 +726,7 @@ Derivable Traits:
 - `Default`
 - `Debug`
 
-```rs linenums="1"
+```rs
 #[derive(Trait)]  // derive a trait for the struct
 #[derive(Trait, Trait, ...)]  // derive multiple traits
 struct Struct {
@@ -738,7 +738,7 @@ struct Struct {
 
 Trait Bound are used to require a generic to implement specific traits and guarantee that a type will have the necessary behaviours.
 
-```rs linenums="1"
+```rs
 fn generic_method<T: RequiredTrait>() {}
 fn generic_method<T: RequiredTrait + RequiredTrait>() {}  // multiple bounds
 // or
@@ -760,7 +760,7 @@ fn method_signature(param: &(impl TraitOne + TraitTwo)) -> Type {}
 
 ### Trait Extensions
 
-```rs linenums="1"
+```rs
 extern crate foo;
 use foo::Foo;
 
@@ -784,7 +784,7 @@ Rust accomplishes this by performing *monomorphization* of the code that is usin
 Monomorphization is the process of turning generic code into specific code by filling in the concrete types that are used when compiled.
 For this reason if a function as a trait as return type (trait bound), only a single type that implements the trait can be returned.
 
-```rs linenums="1"
+```rs
 struct GenericStruct<T, U> {
     T generic_field,
     U generic_field,
@@ -820,7 +820,7 @@ fn generic<T: Trait>() -> Type { }  // use generic constraint
 *Associated types* connect a type placeholder with a trait such that the trait method definitions can use these placeholder types in their signatures.  
 The implementor of a trait will specify the concrete type to be used instead of the placeholder type for the particular implementation.
 
-```rs linenums="1"
+```rs
 trait Iterator {
     type Item;
 
@@ -850,7 +850,7 @@ In memory, a trait object is a fat pointer consisting of a pointer to the value,
 
 > **Note**: Rust automatically converts ordinary references into trait objects when needed
 
-```rs linenums="1"
+```rs
 let trait_object = &mut dyn Trait = &mut source;
 let trait_object: Box<dyn Trait> = Box::new(source);  // same for Rc<T>, Arc<T>, ...
 ```
@@ -858,7 +858,7 @@ let trait_object: Box<dyn Trait> = Box::new(source);  // same for Rc<T>, Arc<T>,
 This works differently from defining a struct or function that uses a generic type parameter with trait bounds.  
 A generic type parameter can only be substituted with *one concrete type* at a time, whereas trait objects allow for *multiple* concrete types to fill in for the trait object at runtime.
 
-```rs linenums="1"
+```rs
 fn func() -> Box<dyn Trait> { }  // return something that implements the specified trait
 ```
 
@@ -883,7 +883,7 @@ The annotation does not affect how long the references live.
 
 In case of different lifetimes the complier will use the most restrictive.
 
-```rs linenums="1"
+```rs
 // lifetime annotation syntax
 fn func<'a>(x: &'a Type, y: &'a Type) -> &'a Type { }
 
@@ -916,7 +916,7 @@ They describe situations that do not require explicit lifetime annotations.
 
 ## Enums
 
-```rs linenums="1"
+```rs
 // enum definition
 enum Enum
 {
@@ -950,7 +950,7 @@ A *match expression* is made up of *arms*. An arm consists of a *pattern* and th
 
 > **Note**: `match` arms must be exhaustive for compilation.
 
-```rs linenums="1"
+```rs
 enum Enum {
     Variant1,
     Variant2,
@@ -990,7 +990,7 @@ fn match_variant(e: Enum) {
 
 > **Note**: `..` in slices matches *any number* of elements. `..` in structs *ignores* all remaining fields
 
-```rs linenums="1"
+```rs
 // unpack a struct into local variables
 let Struct { local_1, local_2, local_3, .. } = source;
 
@@ -1012,7 +1012,7 @@ A **refutable pattern** is one that might not match, like `Ok(x)`. Refutable pat
 
 Refutable patterns are also allowed in `if let` and `while let` expressions:
 
-```rs linenums="1"
+```rs
 // handle just one enum variant specially
 if let Enum::VariantX(_, _) = source { }
 
@@ -1034,7 +1034,7 @@ The `Option` type is used in many places because it encodes the very common scen
 
 `Result<T, E>` is the type used for returning and propagating errors. It is an enum with the variants, `Ok(T)`, representing success and containing a value, and `Err(E)`, representing error and containing an error value.
 
-```rs linenums="1"
+```rs
 // std implementation
 enum Option<T> {
     Some(T),
@@ -1101,7 +1101,7 @@ Ending an expression with `?` will result in the unwrapped success (`Ok`) value,
 
 When working with multiple error types is useful to return a "generic error" type. All the standard library error types can be represented by `Box<dyn std::Error + Send + Sync + 'static>`.
 
-```rs linenums="1"
+```rs
 // convenience type aliases for the generic error
 type GenericError = Box<dyn std::Error + Send + Sync + 'static>;
 type GenericResult<T> = Result<T; GenericError>;
@@ -1111,7 +1111,7 @@ type GenericResult<T> = Result<T; GenericError>;
 
 ### Custom Error Types
 
-```rs linenums="1"
+```rs
 use thiserror::Error;  // utility crate for custom errors
 
 #[derive(Error, Debug)]
@@ -1132,7 +1132,7 @@ pub struct JsonError {
 Vectors allow to store more than one value in a single data structure that puts all the values next to each other in memory. Vectors can only store values of the *same type*.  
 Like any other struct, a vector is freed when it goes out of scope. When the vector gets dropped, all of its contents are also dropped.
 
-```rs linenums="1"
+```rs
 let v: Vec<Type> = Vec<Type>::new();  // empty vec init
 let mut v: vec![item1, item2, ...];  // vec init (type inferred)
 
@@ -1151,7 +1151,7 @@ for i in mut &v {
 
 A vector can hold different types if those type are variants of the same enum. It's also possible to use trait objects.
 
-```rs linenums="1"
+```rs
 enum Enum {
     Int(i32),
     Float(f64),
@@ -1169,7 +1169,7 @@ let v = vec![
 
 Stores data in key-value pairs.
 
-```rs linenums="1"
+```rs
 use std::collections::HashMap;
 
 let map: HashMap<K, V> = HashMap::new();
@@ -1191,7 +1191,7 @@ Within these limited contexts, the compiler is reliably able to infer the types
 The first time a closure is called with an argument, the compiler infers the type of the parameter and the return type of the closure.  
 Those types are then locked into the closure and a type error is returned if a different type is used with the same closure.
 
-```rs linenums="1"
+```rs
 // closure definition
 let closure = |param1, param2| <expr>;
 let closure = |param1, param2| {/* multiple lines of code */};
@@ -1209,7 +1209,7 @@ To define structs, enums, or function parameters that use closures generics and
 
 The `Fn` traits are provided by the standard library. All closures implement at least one of the traits: `Fn`, `FnMut`, or `FnOnce`.
 
-```rs linenums="1"
+```rs
 struct ClosureStruct<T> where T: Fn(u32) -> u32 {
     closure: T,
 }
@@ -1238,7 +1238,7 @@ All closures implement `FnOnce` because they can all be called at least once. Cl
 To force the closure to take ownership of the values it uses in the environment, use the `move` keyword before the parameter list.  
 This technique is mostly useful when passing a closure to a new thread to move the data so it's owned by the new thread.
 
-```rs linenums="1"
+```rs
 let closure = move |param| <expr>;
 ```
 
@@ -1265,7 +1265,7 @@ The *iterator pattern* allows to perform some task on a sequence of items in tur
 
 In Rust, iterators are *lazy*, meaning they have no effect until a call to methods that consume the iterator to use it up.
 
-```rs linenums="1"
+```rs
 // iterator trait
 pub trait Iterator {
     type Item;
@@ -1285,7 +1285,7 @@ Other methods defined on the `Iterator` trait, known as *iterator adaptors*, all
 It's possible to chain multiple calls to iterator adaptors to perform complex actions in a readable way.  
 But because all iterators are lazy, a call one of the consuming adaptor methods is needed to get the results.
 
-```rs linenums="1"
+```rs
 let iterator: = vec![1, 2, 3];
 iterator
     .map(|x| x + 1)  // iterator adapter
@@ -1295,7 +1295,7 @@ iterator
 
 ### Custom Iterators
 
-```rs linenums="1"
+```rs
 struct Counter {
     count: u32,
 }
@@ -1353,7 +1353,7 @@ Boxes don't have performance overhead, other than storing their data on the heap
 - Transferring ownership of a large amount of data but ensuring the data won't be copied when you do so
 - Owning a value and which implements a particular trait rather than being of a specific type
 
-```rs linenums="1"
+```rs
 let _box = Box::new(pointed_value);
 ```
 
@@ -1362,7 +1362,7 @@ let _box = Box::new(pointed_value);
 Implementing the `Deref` trait allows to customize the behavior of the dereference operator, `*`.
 By implementing `Deref` in such a way that a smart pointer can be treated like a regular reference.
 
-```rs linenums="1"
+```rs
 struct CustomSmartPointer<T>(T);
 
 impl<T> CustomSmartPointer<T> {
@@ -1389,7 +1389,7 @@ let v = *(s.deref());
 It works only on types that implement the `Deref` trait and converts such a type into a reference to another type.  
 Deref coercion was added to Rust so that programmers writing function and method calls don't need to add as many explicit references and dereferences with `&` and `*`.
 
-```rs linenums="1"
+```rs
 fn hello(name: &str) {
     println!("Hello {}", name);
 }
@@ -1414,7 +1414,7 @@ Rust does *deref coercion* when it finds types and trait implementations in thre
 
 `Drop` allows to customize what happens when a value is about to go out of scope. It-s possible to provide an implementation for the `Drop` trait on any type.
 
-```rs linenums="1"
+```rs
 struct CustomSmartPointer<T>(T);
 
 impl<T> Drop for CustomSmartPointer<T> {
@@ -1438,7 +1438,7 @@ Rust provides the *reference-counted* pointer types `Rc<T>` and `Arc<T>`.
 The `Rc<T>` and `Arc<T>` types are very similar; the only difference between them is that an `Arc<T>` is safe to share between
 threads directly (the name Arc is short for *atomic* reference count) whereas a plain `Rc<T>` uses faster non-thread-safe code to update its reference count.
 
-```rs linenums="1"
+```rs
 use std::rc::Rc;
 
 let s: Rc<String> = Rc::new("some string".to_string());
@@ -1496,7 +1496,7 @@ This creates memory leaks because the reference count of each item in the cycle
 
 ### Reading Files
 
-```rs linenums="1"
+```rs
 use std::fs;
 
 let contents: Vec<u8> = fs::read("path/to/file").unwrap_or_default();
@@ -1507,7 +1507,7 @@ contents.lines(); // iterator over text lines
 
 ### Writing Files
 
-```rs linenums="1"
+```rs
 use std::fs;
 use std::io::Write;  // write trait
 // or
@@ -1531,7 +1531,7 @@ The extern keyword is used in two places in Rust:
 
 `extern` is used in two different contexts within FFI. The first is in the form of external blocks, for declaring function interfaces that Rust code can call foreign code by.
 
-```rs linenums="1"
+```rs
 #[link(name = "my_c_library")]
 extern "C" {
     fn my_c_function(x: i32) -> bool;
@@ -1544,7 +1544,7 @@ Working with non-Rust languages and FFI is inherently unsafe, so wrappers are us
 
 The mirror use case of FFI is also done via the extern keyword:
 
-```rs linenums="1"
+```rs
 #[no_mangle]
 pub extern "C" fn callable_from_c(x: i32) -> bool {
     x % 3 == 0

docs/languages/rust/unit-tests.md

@@ -2,7 +2,7 @@
 
 ## Test Functions
 
-```rs linenums="1"
+```rs
 // module code here
 
 #[cfg(test)]
@@ -33,7 +33,7 @@ mod tests {
 
 ## Controlling How Tests Are Run
 
-```sh linenums="1"
+```sh
 cargo test -- --test-threads=<number>  # run tests in parallel (1 no parallelism)
 cargo test -- --show-output  # show content printed in stdout in each test
 cargo test <test_name>  # run only a specific test

docs/languages/swift/swift.md

@@ -4,7 +4,7 @@
 
 ### Macro
 
-```swift linenums="1"
+```swift
 #if DEBUG
 
 // contents compiled only if in DEBUG build
@@ -14,7 +14,7 @@
 
 ### Comments
 
-```swift linenums="1"
+```swift
 // single line comment
 
 /*  
@@ -24,7 +24,7 @@ multi line comment
 
 ### Variables
 
-```swift linenums="1"
+```swift
 var variable = value  // implicit variable init (auto-determine type)
 var variable: Type = value  // explicit variable init
 var variable: Type? = value  // explicit nullable variable init
@@ -32,13 +32,13 @@ var variable: Type? = value  // explicit nullable variable init
 
 ### Constants
 
-```swift linenums="1"
+```swift
 let CONSTANT = value  // constant init (value can be assigned at runtime)
 ```
 
 ### Console Output
 
-```swift linenums="1"
+```swift
 print()  // empty line
 print(variable)
 print("string")
@@ -46,7 +46,7 @@ print("string")
 
 ## Strings
 
-```swift linenums="1"
+```swift
 var string "Text: \(<expr>)"  // string interpolation
 var string = "Hello" + "There"  // string concatenation
 
@@ -56,7 +56,7 @@ to make a string span multiple lines"""
 
 ## Array
 
-```swift linenums="1"
+```swift
 var array = ["firstItem", "secondItem", ...]
 var array = [Type()]  // init empty homogeneous array
 
@@ -81,7 +81,7 @@ It's possible to use a tuple type as the return type of a function to enable the
 It's possible to name the elements of a tuple type and use those names to refer to the values of the individual elements.
 An element name consists of an identifier followed immediately by a colon (:).
 
-```swift linenums="1"
+```swift
 var tuple: (Type, Type) = (value, value)  // explicit type
 var tuple = (value, value)  // implicit type
 tuple.0  // item access
@@ -94,21 +94,21 @@ tuple.name1  // item access
 
 ### Tuple Decomposition
 
-```swift linenums="1"
+```swift
 var tuple = (value1, value2)
 var (var1, var2) = tuple  // var1 = value1, var2 = value2
 ```
 
 ## Type Identifier
 
-```swift linenums="1"
+```swift
 typealias Point = (Int, Int)
 var origin: (0, 0)
 ```
 
 ## Dictionary
 
-```swift linenums="1"
+```swift
 var dict = [
     "key": "value",
     ...
@@ -204,7 +204,7 @@ dict[key] = value // value update
 
 ### Nil Checks
 
-```swift linenums="1"
+```swift
 variable ?? value
 // same as
 if(variable == nil) { variable = value }
@@ -212,7 +212,7 @@ if(variable == nil) { variable = value }
 
 ## If-Else
 
-```swift linenums="1"
+```swift
 if condition {
     // code here
 } else if condition {
@@ -229,7 +229,7 @@ if var0 != nil { /* statements */ }
 
 ### Switch
 
-```swift linenums="1"
+```swift
 switch <value> {
     case <pattern/key>:
         // code here
@@ -249,7 +249,7 @@ switch <value> {
 
 ### For Loop
 
-```swift linenums="1"
+```swift
 // range based for
 for i in start...end { /* statements */ }  // end included
 for i in start..<end { /* statements */ }  // end excluded
@@ -266,7 +266,7 @@ for (key, value) in dict {
 
 ### While Loop
 
-```swift linenums="1"
+```swift
 while condition {
     // code here
 }
@@ -279,7 +279,7 @@ repeat {
 
 ## Functions
 
-```swift linenums="1"
+```swift
 // "void function"
 func funcName(param: Type, ...) {
     // code here
@@ -314,14 +314,14 @@ funcWithLabels(value, label: value, ...)
 
 ### Passing Functions as Parameters
 
-```swift linenums="1"
+```swift
 func f(param: Type) -> Type {}
 func g(f: (Type) -> Type) {}  // (Type) -> Type are the passed func input and output types
 ```
 
 ### Functions Returning Functions
 
-```swift linenums="1"
+```swift
 func f() -> ((Type) -> Type) {
     func g(param: Type) -> type {}
 
@@ -334,7 +334,7 @@ func f() -> ((Type) -> Type) {
 **Closures** are self-contained blocks of functionality that can be passed around and used in code.
 Closures in Swift are similar to blocks in C and Objective-C and to lambdas in other programming languages.
 
-```swift linenums="1"
+```swift
 { (parameters: Type) -> Type in
     // statements
 }
@@ -347,7 +347,7 @@ Closures in Swift are similar to blocks in C and Objective-C and to lambdas in o
 
 ### Enum Definition
 
-```swift linenums="1"
+```swift
 enum EnumName {
     case key1
     case key2
@@ -359,7 +359,7 @@ EnumName.key1 // key1
 
 ### Enum with Raw Values
 
-```swift linenums="1"
+```swift
 enum EnumName: Type {
     case key1 = value
     case key2 = value
@@ -378,7 +378,7 @@ enum IntegerEnum: Int {
 
 ### Matching Enumeration Values with a Switch Statement
 
-```swift linenums="1"
+```swift
 enum Rank: Int {
     case ace = 1, two, three, four, five, six, seven, eight, nine, ten
     case jack, queen, king
@@ -407,7 +407,7 @@ Rank.jack.rawValue // 11
 
 ## Struct (Value Type)
 
-```swift linenums="1"
+```swift
 struct StructName {
     var attribute = value  // instance variable
     private var _attribute: Type  // backing field for property
@@ -442,7 +442,7 @@ var structure = StructName()  // struct instantiation
 
 ### Class Definition & Instantiation
 
-```swift linenums="1"
+```swift
 class ClassName {
     var attribute = value  // instance variable
     private var _attribute: Type  // backing field for property
@@ -479,7 +479,7 @@ Do actions before/after modifying a property value.
 
 > **Note**: `willSet` and `didSet` do not *set* the value of the property.
 
-```swift linenums="1"
+```swift
 class ClassName {
 
     var _attribute: Type
@@ -501,7 +501,7 @@ class ClassName {
 
 ### Inheritance
 
-```swift linenums="1"
+```swift
 class Derived: SuperClass {
 
     var attribute: Type
@@ -518,7 +518,7 @@ class Derived: SuperClass {
 
 ### Exception Handling
 
-```swift linenums="1"
+```swift
 guard let variable = <expression>
 else {
     /* statements */

docs/misc/graph-ql.md

@@ -14,7 +14,7 @@ A GraphQL service is created by defining types and fields on those types, then p
 
 The most basic components of a GraphQL schema are object types, which just represent a kind of object fetchable from the service, and what fields it has.
 
-```graphql linenums="1"
+```graphql
 type Type {
   field: Type
   field: Type!  # non-nullable type
@@ -29,7 +29,7 @@ Every field on a GraphQL object type can have zero or more arguments. All argume
 
 Arguments can be either *required* or *optional*. When an argument is optional, it's possible to define a default value.
 
-```graphql linenums="1"
+```graphql
 type Type {
   field: Type,
   field(namedArg: Type = defaultValue): Type
@@ -55,7 +55,7 @@ GraphQL comes with a set of default scalar types out of the box:
 
 In most GraphQL service implementations, there is also a way to specify custom scalar types.
 
-```graphql linenums="1"
+```graphql
 scalar ScalarType
 ```
 
@@ -70,7 +70,7 @@ This allows to:
 1. Validate that any arguments of this type are one of the allowed values
 2. Communicate through the type system that a field will always be one of a finite set of values
 
-```graphql linenums="1"
+```graphql
 enum Type{
   VALUE,
   VALUE,
@@ -97,7 +97,7 @@ Like many type systems, GraphQL supports interfaces. An Interface is an abstract
 
 Interfaces are useful when returning an object or set of objects, but those might be of several different types.
 
-```graphql linenums="1"
+```graphql
 interface Interface {
   fieldA: TypeA
   fieldB: TypeB
@@ -115,7 +115,7 @@ type Type implements Interface {
 
 Interfaces are useful when returning an object or set of objects, but those might be of several different types.
 
-```graphql linenums="1"
+```graphql
 union Union = TypeA | TypeB | TypeC
 ```
 
@@ -125,7 +125,7 @@ union Union = TypeA | TypeB | TypeC
 
 In the GraphQL schema language, input types look exactly the same as regular object types, but with the keyword input instead of type:
 
-```graphql linenums="1"
+```graphql
 input Input {
   field: Type,
   ...
@@ -141,7 +141,7 @@ Input object types also can't have arguments on their fields.
 
 ### Simple Query
 
-```graphql linenums="1"
+```graphql
 {
   field {  # root field
     ...  # payload
@@ -149,7 +149,7 @@ Input object types also can't have arguments on their fields.
 }
 ```
 
-```json linenums="1"
+```json
 {
   "data" : {
     "field": {
@@ -167,7 +167,7 @@ But in GraphQL, every field and nested object can get its own set of arguments,
 
 It's aldo possible to pass arguments into scalar fields, to implement data transformations once on the server, instead of on every client separately.
 
-```graphql linenums="1"
+```graphql
 {
   fieldA(arg: value)  # filter results
   fieldB(arg: value)
@@ -177,7 +177,7 @@ It's aldo possible to pass arguments into scalar fields, to implement data trans
 
 ### Aliases
 
-```graphql linenums="1"
+```graphql
 {
   aliasA: field(arg: valueA) {
     field
@@ -193,7 +193,7 @@ It's aldo possible to pass arguments into scalar fields, to implement data trans
 Fragments allow to construct sets of fields, and then include them in queries where that are needed.
 The concept of fragments is frequently used to split complicated application data requirements into smaller chunks.
 
-```graphql linenums="1"
+```graphql
 {
   aliasA: field(arg: valueA) {
     ...fragment
@@ -214,7 +214,7 @@ fragment fragment on Type {
 
 It is possible for fragments to access variables declared in the query or mutation.
 
-```graphql linenums="1"
+```graphql
 query Query($var: Type = value) {
     aliasA: field(arg: valueA) {
   ...fragment
@@ -240,7 +240,7 @@ The *operation type* is either `query`, `mutation`, or `subscription` and descri
 
 The *operation name* is a meaningful and explicit name for the operation. It is only required in multi-operation documents, but its use is encouraged because it is very helpful for debugging and server-side logging. When something goes wrong it is easier to identify a query in the codebase by name instead of trying to decipher the contents.
 
-```graphql linenums="1"
+```graphql
 query Operation {
   ...
 }
@@ -254,7 +254,7 @@ When  working with variables, three things need to be done:
 2. Declare `$variableName` as one of the variables accepted by the query
 3. Pass `variableName: value` in the separate, transport-specific (usually JSON) variables dictionary
 
-```graphql linenums="1"
+```graphql
 query Operation($var: Type = defaultValue) {
   field(arg: $var) {
     field
@@ -288,7 +288,7 @@ Operations of mutations:
 - **Updating** existing data
 - **Deleting** existing data
 
-```graphql linenums="1"
+```graphql
 mutation Operation {
   createObject(arg: value, ...) {
     field
@@ -301,7 +301,7 @@ mutation Operation {
 
 Open a stable connection with the server to receive real-time updates on the operations happening.
 
-```graphql linenums="1"
+```graphql
 subscription Operation {
   event {  # get notified when event happens
     field  # data received on notification
@@ -314,7 +314,7 @@ subscription Operation {
 
 If you are querying a field that returns an interface or a union type, you will need to use inline fragments to access data on the underlying concrete type. Named fragments can also be used in the same way, since a named fragment always has a type attached.
 
-```graphql linenums="1"
+```graphql
 query Operation($var: Type) {
     field(arg: $var) {  # interface of union
   field
@@ -332,7 +332,7 @@ query Operation($var: Type) {
 
 GraphQL allows to request `__typename`, a meta field, at any point in a query to get the name of the object type at that point.
 
-```graphql linenums="1"
+```graphql
 {
     field(arg: value) {
   __typename
@@ -357,7 +357,7 @@ If a field produces a scalar value like a string or number, then the execution c
 
 At the top level of every GraphQL server is a type that represents all of the possible entry points into the GraphQL API, it's often called the *Root* type or the *Query* type.
 
-```graphql linenums="1"
+```graphql
 # root types for entry-points
 
 type Query {

docs/misc/regular-expressions.md

@@ -40,7 +40,7 @@ A **character class** matches any one of a set of characters.
 
 ### Subexpressions
 
-```regex title="Regex Syntax" linenums="1"
+```regex title="Regex Syntax"
 (subexpression)
 ```
 
@@ -66,7 +66,7 @@ It's possible to access the captured group in the following ways:
 
 ### Named Subexpressions
 
-```regex title="Regex Syntax" linenums="1"
+```regex title="Regex Syntax"
 (?<name> subexpression)
 (?'name' subexpression)
 ```
@@ -90,7 +90,7 @@ It's possible to access the named captured group in the following ways:
 
 ### Noncapturing groups
 
-```regex title="Regex Syntax" linenums="1"
+```regex title="Regex Syntax"
 (?:subexpression)
 ```
 
@@ -98,7 +98,7 @@ The *subexpression* is any valid regular expression pattern. The noncapturing gr
 
 ### Zero-width positive lookahead assertions
 
-```regex title="Regex Syntax" linenums="1"
+```regex title="Regex Syntax"
 (?= subexpression)
 ```
 
@@ -110,7 +110,7 @@ It's possible to use a zero-width positive lookahead assertion to ensure that a
 
 ### Zero-width negative lookahead assertions
 
-```regex title="Regex Syntax" linenums="1"
+```regex title="Regex Syntax"
 (?! subexpression)
 ```
 
@@ -120,7 +120,7 @@ A zero-width negative lookahead assertion is typically used either at the beginn
 
 ### Zero-width positive lookbehind assertions
 
-```regex title="Regex Syntax" linenums="1"
+```regex title="Regex Syntax"
 (?<= subexpression)
 ```
 
@@ -130,7 +130,7 @@ Zero-width positive lookbehind assertions are typically used at the beginning of
 
 ### Zero-width negative lookbehind assertions
 
-```regex title="Regex Syntax" linenums="1"
+```regex title="Regex Syntax"
 (?<! subexpression)
 (?> subexpression)
 ```
@@ -141,7 +141,7 @@ Zero-width negative lookbehind assertions are typically used at the beginning of
 
 ### Atomic groups
 
-```regex title="Regex Syntax" linenums="1"
+```regex title="Regex Syntax"
 (?> subexpression )
 ```
 

docs/misc/ssh.md

@@ -4,7 +4,7 @@
 
 ## Basics
 
-```sh linenums="1"
+```sh
 ssh user@destination <command> # exec <command> in remote machine ($SHELL if omitted)
 ssh user@destination -i <path/to/private-key>  # use key for auth
 ssh user@destination -f  # exec ssh in the background
@@ -19,7 +19,7 @@ ssh user@destination -t  # force pseudo-tty emulation
 
 Connect to the final destination jumping through the specifies other destinations.
 
-```sh linenums="1"
+```sh
 ssh -J user_1@destination_1,user_2@destination_2 user@final_destination
 ```
 
@@ -31,7 +31,7 @@ ssh -J user_1@destination_1,user_2@destination_2 user@final_destination
 
 Start listening on `local_address:local_port` and forward any traffic to `remote_address:remote_port`.
 
-```sh linenums="1"
+```sh
 ssh -N -f -L local_address:local_port:remote_address:remote_port user@destination
 ssh -N -f -L local_port:remote_address:remote_port user@destination  # local_address defaults to localhost
 ```
@@ -40,6 +40,6 @@ ssh -N -f -L local_port:remote_address:remote_port user@destination  # local_add
 
 Start listening on `remote_address:remote_port` and forward any traffic to `local_address:local_port`.
 
-```sh linenums="1"
+```sh
 ssh -N -f -R remote_address:remote_port:local_address:local_port user@destination
 ```