update annotations

docs/bash/commands.md

@@ -1,6 +1,6 @@
 # Bash Commands
 
-**NOTE**: Square brackets (`[]`) denotes optional commands/flags/arguments. Uppercase denotes placeholders for arguments.
+> **Note**: Square brackets (`[]`) denotes optional commands/flags/arguments. Uppercase denotes placeholders for arguments.
 
 ## Basic Commands
 

docs/database/mongo-db.md

@@ -114,7 +114,7 @@ db.<collection>.insertMany([ { document }, { document }, ... ], options)  # inse
 db.<collection>.insertMany([ { document }, { document } ] , { "ordered": false })  # allow the unordered insertion, only documents that cause errors wont be inserted
 ```
 
-**NOTE**: If `insertMany()` fails the already inserted documents are not rolled back but all the successive ones (even the correct ones) will not be inserted.
+> **Note**: If `insertMany()` fails the already inserted documents are not rolled back but all the successive ones (even the correct ones) will not be inserted.
 
 ### Read
 

docs/docker/docker.md

@@ -149,7 +149,7 @@ ENTRYPOINT [“executable”]
 CMD [“arg1”, “arg2”]
 ```
 
-**NOTE**: Anything defined in CMD can be overridden by passing arguments in `docker run` command.
+> **Note**: Anything defined in CMD can be overridden by passing arguments in `docker run` command.
 
 ### `ENTRYPOINT`
 

docs/dotnet/C#/C#.md

@@ -351,7 +351,7 @@ While records can be mutable, they're primarily intended for supporting immutabl
   - Built-in formatting for display
 - Support for inheritance hierarchies
 
-**NOTE**: A _positional record_ and a _positional readonly record struct_ declare init-only properties. A _positional record struct_ declares read-write properties.
+> **Note**: A _positional record_ and a _positional readonly record struct_ declare init-only properties. A _positional record struct_ declares read-write properties.
 
 ### `with`-expressions
 
@@ -370,7 +370,7 @@ The `with` expression causes the copy constructor to get called, and then applie
 protected Record(Record original) { /* copy all the fields */ } // generated
 ```
 
-**NOTE**: it's possible to define a custom copy constructor tha will be picked up by the `with` expression.
+> **Note**: it's possible to define a custom copy constructor tha will be picked up by the `with` expression.
 
 ### `with`-expressions & Inheritance
 
@@ -913,8 +913,8 @@ foreach (type item in iterabile)
 }
 ```
 
-**NOTE**: Due to the use of an _iterator_, the variable declared in a foreach statement cannot be used to modify the value of the current item.  
-**NOTE**: From C# 9 it's possible to implement `GetEnumerator()` as an _extension method_ making enumerable an class that normally isn't.
+> **Note**: Due to the use of an _iterator_, the variable declared in a foreach statement cannot be used to modify the value of the current item.  
+> **Note**: From C# 9 it's possible to implement `GetEnumerator()` as an _extension method_ making enumerable an class that normally isn't.
 
 Example:
 
@@ -965,7 +965,7 @@ In unchecked code block the mathematic overflow is _ignored_ end the result is _
 It's possible configure the C# compiler to put everything into a checked context by default, so that only explicitly unchecked expressions and statements will be able to overflow silently.  
 It is done by editing the `.csproj` file, adding `<CheckForOverflowUnderflow>true</CheckForOverflowUnderflow>` inside a `<PropertyGroup>`.
 
-**NOTE**: checking can make individual integer operations several times slower.
+> **Note**: checking can make individual integer operations several times slower.
 
 ```cs
 checked
@@ -1158,7 +1158,7 @@ MethodName(value1);  // use defaults for optional arguments
 MethodName(required: value, secondOptional: value);  // use default for first optional but pass second optional
 ```
 
-**NOTE**: If the caller provides an argument for any one of a succession of optional parameters, it must provide arguments for all preceding optional parameters. Comma-separated gaps in the argument list are not supported.
+> **Note**: If the caller provides an argument for any one of a succession of optional parameters, it must provide arguments for all preceding optional parameters. Comma-separated gaps in the argument list are not supported.
 
 ### Passing Values By Reference (`ref`, `out`, `in`)
 
@@ -1180,7 +1180,7 @@ Use cases:
 - `ref`: move data bidirectionally between method and call scope
 - `in`: pass large value type (e,g, struct) as a reference avoiding copying large amounts of data (must be readonly, copied regardless otherwise)
 
-**NOTE**: use `in` only with readonly value types, because mutable value types can undo the performance benefits. (Mutable value types are typically a bad idea in any case.)
+> **Note**: use `in` only with readonly value types, because mutable value types can undo the performance benefits. (Mutable value types are typically a bad idea in any case.)
 
 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.
@@ -1244,7 +1244,7 @@ Extension methods allow their usage applied to the extended type as if their dec
 Extension methods are not really members of the class for which they are defined.  
 It's just an illusion maintained by the C# compiler, one that it keeps up even in situations where method invocation happens implicitly.
 
-**NOTE**: Extension Method can be declared only inside static classes. Extension methods are available only if their namespace is imported with the `using` keyword.
+> **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
 public static class ExtensionMethods
@@ -1270,7 +1270,7 @@ When a `yield return` statement is reached, the current location in code is reme
 
 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()`.
+> **Note**: Since an iterator returns an `IEnumerable<T>` is can be used to implement a `GetEnumerator()`.
 
 ```cs
 // simple iterator
@@ -1322,7 +1322,7 @@ public struct Point
 }
 ```
 
-**NOTE**: From C# 10 is possible to have a parameterless constructor and make a new struct using a `with` statement.
+> **Note**: From C# 10 is possible to have a parameterless constructor and make a new struct using a `with` statement.
 
 The only way to affect a struct variable both inside a method and outside is to use the `ref` keyword;
 
@@ -1464,10 +1464,10 @@ class Class
 }
 ```
 
-**NOTE**: The `init` accessor is a variant of the `set` accessor which can only be called during object initialization.  
+> **Note**: The `init` accessor is a variant of the `set` accessor which can only be called during object initialization.  
 Because `init` accessors can only be called during initialization, they are allowed to _mutate_ `readonly` fields of the enclosing class, just like in a constructor.
 
-**NOTE**: creating at least one constructor hides the one provided by default (w/ zero parameters).
+> **Note**: creating at least one constructor hides the one provided by default (w/ zero parameters).
 
 ### [Object and Collection Initializers](https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/object-and-collection-initializers)
 
@@ -1604,7 +1604,7 @@ Members marked as `abstract` must be implemented by non-abstract classes that de
   The `sealed` modifier prevents a class from being inherited and the `abstract` modifier requires a class to be inherited.
 - A _non-abstract_ class derived from an `abstract` class must include actual implementations of all inherited `abstract` methods and accessors.
 
-**NOTE**: Use the `abstract` modifier in a method or property declaration to indicate that the method or property does not contain implementation.
+> **Note**: Use the `abstract` modifier in a method or property declaration to indicate that the method or property does not contain implementation.
 
 `abstract` methods have the following features:
 
@@ -1656,7 +1656,7 @@ IClonable.Clone();  //  Creates a new object that is a copy of the current insta
 
 Deconstruction is not limited to tuples. By providing a `Deconstruct(...)` method(s) C# allows to use the same syntax with the users types.
 
-**NOTE**: Types with a deconstructor can also use _positional pattern matching_.
+> **Note**: Types with a deconstructor can also use _positional pattern matching_.
 
 ```cs
 public readonly struct Size
@@ -1790,7 +1790,7 @@ A type defined at _global scope_ can be only `public`or `internal`.
 private wouldn't make sense since that makes something accessible only from within its containing type, and there is no containing type at global scope.  
 But a nested type does have a containing type, so if a nested type is `private`, that type can be used only from inside the type within which it is nested.
 
-**NOTE**: Code in a nested type is allowed to use nonpublic members of its containing type. However, an instance of a nested type does not automatically get a reference to an instance of its containing type.
+> **Note**: Code in a nested type is allowed to use nonpublic members of its containing type. However, an instance of a nested type does not automatically get a reference to an instance of its containing type.
 
 ---
 
@@ -1827,7 +1827,7 @@ public interface IContract
 public interface IContract<T> {}  // interfaces can be generic
 ```
 
-**NOTE**: Interfaces are reference types. Despite this, it's possible tp implement interfaces on both classes and structs.  
+> **Note**: Interfaces are reference types. Despite this, it's possible tp implement interfaces on both classes and structs.  
 However, be careful when doing so with a struct, because when getting hold of an interface-typed reference to a struct, it will be a reference to a _box_,  
 which is effectively an object that holds a copy of a struct in a way that can be referred to via a reference.
 
@@ -1928,7 +1928,7 @@ One reason for this is that value types are not normally used by reference, whic
 Since a derived class inherits everything the base class has—all its fields, methods, and other members,  
 both public and private—an instance of the derived class can do anything an instance of the base could do.
 
-**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.  
+> **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
@@ -2032,7 +2032,7 @@ Generic type parameters support covariance and contravariance to provide greater
 
 ![covariance-vs-contravariance](../../img/dotnet_covariant_contravariant.png)
 
-**NOTE**: annotate generic type parameters with `out` and `in` annotations to specify whether they should behave covariantly or contravariantly.
+> **Note**: annotate generic type parameters with `out` and `in` annotations to specify whether they should behave covariantly or contravariantly.
 
 ```cs
 public class Base {};
@@ -2096,7 +2096,7 @@ multicastDelegate += Method;  // add method to delegate
 multicastDelegate -= Method;  // remove method from delegate
 ```
 
-**NOTE**: Delegate removal behaves in a potentially surprising way if the delegate removed refers to multiple methods.  
+> **Note**: Delegate removal behaves in a potentially surprising way if the delegate removed refers to multiple methods.  
 Subtraction of a multicast delegate succeeds only if the delegate from which subtract contains all of the methods in the delegate being subtracted _sequentially and in the same order_.
 
 ### Delegate Invocation
@@ -2115,7 +2115,7 @@ multicastDelegate.GetInvocationList();  // list of methods called by the delegat
 
 ### Common Delegate Types
 
-**NOTE**: Each delegate has an overload taking from zero to 16 arguments;
+> **Note**: Each delegate has an overload taking from zero to 16 arguments;
 
 ```cs
 public delegate void Action<in T1, ...>(T1 arg1, ...);
@@ -2281,7 +2281,7 @@ With .NET Core 3.0 or later, .NET assemblies won't be built with an extension of
 Even project types that produce directly runnable outputs (such as console or WPF applications) produce a `.dll` as their primary output.  
 They also generate an executable file too, but it's not a .NET assembly. It's just a bootstrapper that starts the runtime and then loads and executes your application's main assembly.
 
-**NOTE**: C# compiles to a binary intermediate language (IL), which is not directly executable.  
+> **Note**: C# compiles to a binary intermediate language (IL), which is not directly executable.  
 The normal Windows mechanisms for loading and running the code in an executable or DLL won't work with IL, because that can run only with the help of the CLR.
 
 ### .NET MEtadata
@@ -2363,7 +2363,7 @@ As far as the CLR is concerned, there's really only one interesting thing you ca
 
 The build system tells the compiler which version number to use for the assembly name via an assembly-level attribute.
 
-**NOTE**: NuGet packages also have version numbers, and these do not need to be connected in any way to assembly versions. NuGet does treat the components of a package version number as having particular significance: it has adopted the widely used _semantic versioning_ rules.
+> **Note**: NuGet packages also have version numbers, and these do not need to be connected in any way to assembly versions. NuGet does treat the components of a package version number as having particular significance: it has adopted the widely used _semantic versioning_ rules.
 
 #### Culture
 
@@ -2418,7 +2418,7 @@ It's possible to pass arguments to the attribute _constructor_ in the annotation
 [AttrName(Name = value)]  // valorize public properties or fields (no constructor needed)
 ```
 
-**NOTE**: The real name of an attribute ends with "Attribute" (`[AttrName]` refers to the `AttrNameAttribute` class)
+> **Note**: The real name of an attribute ends with "Attribute" (`[AttrName]` refers to the `AttrNameAttribute` class)
 
 ### Multiple Attributes
 
@@ -2485,7 +2485,7 @@ This starts at zero, but at each read or write, the position advances by the num
 The `Read` method returns an `int`. This tells how many bytes were read from the stream, the method _does not guarantee_ to provide the amount of data requested.  
 The reason `Read` is slightly tricky is that some streams are live, representing a source of information that produces data gradually as the program runs.
 
-**NOTE**: If asked for more than one byte at a time, a `Stream` is always free to return less data than requested from Read for any reason. Never presume that a call to `Read` returned as much data as it could.
+> **Note**: If asked for more than one byte at a time, a `Stream` is always free to return less data than requested from Read for any reason. Never presume that a call to `Read` returned as much data as it could.
 
 ### Position & Seeking
 
@@ -2509,7 +2509,7 @@ The Stream class therefore offers a `Flush` method. This tells the stream that i
 A stream automatically flushes its contents when calling `Dispose`. Flush only when it's needed to keep a stream open after writing out buffered data.  
 It is particularly important if there will be extended periods during which the stream is open but inactive.
 
-**NOTE**: When using a `FileStream`, the `Flush` method does not necessarily guarantee that the data being flushed has made it to disk yet. It merely makes the stream pass the data to the OS.  
+> **Note**: When using a `FileStream`, the `Flush` method does not necessarily guarantee that the data being flushed has made it to disk yet. It merely makes the stream pass the data to the OS.  
 Before calling `Flush`, the OS hasn't even seen the data, so if the process terminates suddenly, the data would be lost.  
 After `Flush` has returned, the OS has everything the code has written, so the process could be terminated without loss of data.  
 However, the OS may perform additional buffering of its own, so if the power fails before the OS gets around to writing everything to disk, the data will still be lost.
@@ -2615,7 +2615,7 @@ public FileStream(string path, FileMode mode, FileAccess access, FileShare share
 - `DeleteOnCloseTells`: `FileStream` to delete the file when you call `Dispose`.
 - `EncryptedEncrypts`: the file so that its contents cannot be read by other users.
 
-**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.
+> **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
 // object to read or write to a file (file can be binary)
@@ -2755,7 +2755,7 @@ class ClassName{
 
 Serialization works directly with an object's fields. It uses reflection, which enables it to access all members, whether public or private.
 
-**NOTE**: CLR Serialization produces binary streams in a .NET specific format
+> **Note**: CLR Serialization produces binary streams in a .NET specific format
 
 ---
 
@@ -2803,7 +2803,7 @@ Span<int> numbers = stackalloc int[] { 1, 2, 3 };
 var first = numbers[0];
 ```
 
-**NOTE**: Normally, C# won’t allow to use `stackalloc` outside of code marked as unsafe, since it allocates memory on the stack producing a pointer. However, the compiler makes an exception to this rule when assigning the pointer produced by a `stackalloc` expression directly into a span.
+> **Note**: Normally, C# won’t allow to use `stackalloc` outside of code marked as unsafe, since it allocates memory on the stack producing a pointer. However, the compiler makes an exception to this rule when assigning the pointer produced by a `stackalloc` expression directly into a span.
 
 The fact that `Span<T>` and `ReadOnlySpan<T>` are both `ref struct` types ensures that a span cannot outlive its containing stack frame, guaranteeing that the stack frame on which the stack-allocated memory lives will not vanish while there are still outstanding references to it.
 
@@ -2821,7 +2821,7 @@ This also imposes some potentially more surprising restrictions:
 
 This restriction is necessary for .NET to be able to offer the combination of array-like performance, type safety, and the flexibility to work with multiple different containers.
 
-**NOTE**: it's possible to use spans in local methods, and even declare a ref struct variable in the outer method and use it from the nested one, but with one restriction: it's not possible a delegate that refers to that local method, because this would cause the compiler to move shared variables into an object that lives on the heap.
+> **Note**: it's possible to use spans in local methods, and even declare a ref struct variable in the outer method and use it from the nested one, but with one restriction: it's not possible a delegate that refers to that local method, because this would cause the compiler to move shared variables into an object that lives on the heap.
 
 ## `Memory<T>`
 

docs/dotnet/C#/async-programming.md

@@ -192,4 +192,4 @@ private static async Task<string> ActualMethodAsync(string argument)
 }
 ```
 
-**NOTE**: `await` extracts only the first exception of an `AggregateException`, this can cause the loss of information if a task (or group of tasks) has more than one error.
+> **Note**: `await` extracts only the first exception of an `AggregateException`, this can cause the loss of information if a task (or group of tasks) has more than one error.

docs/dotnet/C#/linq.md

@@ -75,7 +75,7 @@ IEnumerable<TFirst>.Zip(IEnumerable<TSecond> enumerable, Func<TFirst, TSecond, T
 IEnumerable<TFirst>.Zip(IEnumerable<TSecond> enumerable); // Produces a sequence of tuples with elements from the two specified sequences.
 ```
 
-**NOTE**: `Enumerable` provides a set of `static` methods for querying objects that implement `IEnumerable<T>`. Most methods are extensions of `IEnumerable<T>`
+> **Note**: `Enumerable` provides a set of `static` methods for querying objects that implement `IEnumerable<T>`. Most methods are extensions of `IEnumerable<T>`
 
 ```cs
 Enumerable.Method(IEnumerable<T> source, args);

docs/dotnet/asp.net/blazor.md

@@ -375,7 +375,7 @@ public class StateContainer
 }
 ```
 
-**NOTE**: When a user provides an unparsable value to a data-bound element, the unparsable value is automatically reverted to its previous value when the bind event is triggered.
+> **Note**: When a user provides an unparsable value to a data-bound element, the unparsable value is automatically reverted to its previous value when the bind event is triggered.
 
 ## Javascript/.NET Interop
 

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

@@ -1,6 +1,6 @@
 # Minimal API
 
-**NOTE**: Requires .NET 6+
+> **Note**: Requires .NET 6+
 
 ```cs
 var builder = WebApplication.CreateBuilder(args);

docs/dotnet/database/ado.net.md

@@ -17,7 +17,7 @@ The `ADO.NET` classes are found in `System.Data.dll`, and are integrated with th
 - Trusted Connection (WinAuth): `Server=<server_name>; Database=<database>; Trusted_Connection=True;`
 - MARS: `Server=<server_name>; Database=<database>; Trusted_Connection=True; MultipleActiveResultSets=True;`
 
-**NOTE**: *Multiple Active Result Sets* (MARS) is a feature that works with SQL Server to allow the execution of multiple batches on a single connection.
+> **Note**: *Multiple Active Result Sets* (MARS) is a feature that works with SQL Server to allow the execution of multiple batches on a single connection.
 
 ### [SQLite](https://www.connectionstrings.com/sqlite/)
 

docs/javascript/javascript.md

@@ -907,7 +907,7 @@ if(date1 > date2){
 
 [Firefox CORS not HTTP](https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS/Errors/CORSRequestNotHttp)
 
-**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.
+> **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
 "privacy.file_unique_origin": "false"

docs/javascript/jquery.md

@@ -154,7 +154,7 @@ In the JavaScript call the jQuery plugin on the DOM:
 $("form").validate();
 ```
 
-**NOTE**: always link to the [minified](https://developers.google.com/speed/docs/insights/MinifyResources) js files.
+> **Note**: always link to the [minified](https://developers.google.com/speed/docs/insights/MinifyResources) js files.
 
 ## More jQuery
 

docs/javascript/react/react.md

@@ -206,7 +206,7 @@ function Form() {
 // ...
 ```
 
-**NOTE**: The `key` attribute of the component is needed to identify a particular item. It's most useful if the list has to be sorted.
+> **Note**: The `key` attribute of the component is needed to identify a particular item. It's most useful if the list has to be sorted.
 
 ## Hooks
 

docs/javascript/react/redux.md

@@ -94,7 +94,7 @@ const rootReducer = combineReducers({
 });
 ```
 
-**NOTE**: multiple reducers can be triggered by the same action since each one operates on a different portion of the state.
+> **Note**: multiple reducers can be triggered by the same action since each one operates on a different portion of the state.
 
 ## [React-Redux](https://react-redux.js.org/)
 

docs/javascript/svelte/svelte.md

@@ -115,7 +115,7 @@ The full list of modifiers:
 <button on:event|modifier={eventHandler}>
 ```
 
-**NOTE**: It's possible to chain modifiers together, e.g. `on:click|once|capture={...}`.
+> **Note**: It's possible to chain modifiers together, e.g. `on:click|once|capture={...}`.
 
 ## Binding
 

docs/php/composer.md

@@ -37,7 +37,7 @@ require "autoload.php";
 # other code
 ```
 
-**NOTE**: will fuck up if namespaces exists.
+> **Note**: will fuck up if namespaces exists.
 
 ### Multiple Autoloading
 
@@ -81,7 +81,7 @@ Composer will create:
 
 In alternative `composer require <lib>` will add the library to the project and create a `composer.json` if missing.
 
-**NOTE**: to ignore the php version use `composer <command> --ignore-platform-reqs`
+> **Note**: to ignore the php version use `composer <command> --ignore-platform-reqs`
 
 ### Updating Dependencies
 

docs/php/database.md

@@ -62,7 +62,7 @@ $stmt->execute();
 By default PDO converts all results into strings since it is a generic driver for multiple databases.
 Its possible to disable this behaviour setting `PDO::ATTR_STRINGIFY_FETCHES` and `PDO::ATTR_EMULATE_PREPARES` as `false`.
 
-**NOTE**: `FETCH_OBJ` abd `FETCH_CLASS` return classes and don't have this behaviour.
+> **Note**: `FETCH_OBJ` abd `FETCH_CLASS` return classes and don't have this behaviour.
 
 ```php
 pdo->setAttribute()
@@ -99,4 +99,4 @@ $result->finalize();  // close result set, recommended calling before another ex
 $records = $results->fetchArray(SQLITE3_ASSOC);  // extract records as array (false if no results)
 ```
 
-**NOTE**: Result set objects retrieved by calling `SQLite3Stmt::execute()` on the same statement object are not independent, but rather share the same underlying structure. Therefore it is recommended to call `SQLite3Result::finalize()`, before calling `SQLite3Stmt::execute()` on the same statement object again.
+> **Note**: Result set objects retrieved by calling `SQLite3Stmt::execute()` on the same statement object are not independent, but rather share the same underlying structure. Therefore it is recommended to call `SQLite3Result::finalize()`, before calling `SQLite3Stmt::execute()` on the same statement object again.

docs/php/dependency-injection.md

@@ -75,4 +75,4 @@ $container = $builder->build();  // construct container
 $cart = $container->get(Foo::class);  // Instantiate & Inject
 ```
 
-**NOTE**: `get("className")` requires the explicit definition of `className` in the config file. `get(ClassName::class)` does not.
+> **Note**: `get("className")` requires the explicit definition of `className` in the config file. `get(ClassName::class)` does not.

docs/php/plates-templating.md

@@ -58,7 +58,7 @@ Variables in the template are created through an associative array `key => value
 It's possible to create a layout (a model) for a group of pages to make that identical save for the contents.
 In a layout it's possible to create a section called **content** that identifies content that can be specified at runtime.
 
-**NOTE**: Since only the template has the data passed eventual loops have to be done there.
+> **Note**: Since only the template has the data passed eventual loops have to be done there.
 
 ```php
 # index.php

docs/php/unit-tests.md

@@ -153,7 +153,7 @@ class ClassTest extends TestCase
 }
 ```
 
-**NOTE**: `setUp()` and `tearDown()` are called *before* and *after* each test method.
+> **Note**: `setUp()` and `tearDown()` are called *before* and *after* each test method.
 
 ### Data Provider
 

docs/rust/rust.md

@@ -213,7 +213,7 @@ This can happen because Unicode characters can take up to 4 bytes.
 `&String` can be used in place of a `&str` trough *String Coercion*. The `&String` gets converted to a `&str` that borrows the entire string.
 The reverse is not possible since the slice lacks some information about the String.
 
-**NOTE**: When working with functions is easier to always expect a `&str` instead of a `&String`.
+> **Note**: When working with functions is easier to always expect a `&str` instead of a `&String`.
 
 ```rs
 let s = String::from("string literal");
@@ -700,7 +700,7 @@ fn generic_func<T>() -> &T { }  // T could be heap-based type, returning referen
 fn generic<T: Trait>() -> Type { }  // use generic constraint
 ```
 
-**NOTE**: the calling code needs to import your new trait in addition to the external type
+> **Note**: the calling code needs to import your new trait in addition to the external type
 
 ### Trait Objects
 
@@ -845,14 +845,14 @@ fn returns_result() -> Result<T, E> {
 Ending an expression with `?` will result in the unwrapped success (`Ok`) value, unless the result is `Err`, in which case `Err` is returned early from the enclosing function.  
 `?` can only be used in functions that return `Result` because of the early return of `Err` that it provides.
 
-**NOTE**: When `None` is used the type of `Option<T>` must be specified, because the compiler can't infer the type that the `Some` variant will hold by looking only at a `None` value.
-**NOTE**: error values that have the `?` operator called on them go through the `from` function, defined in the `From` trait in the standard library, which is used to convert errors from one type into another
+> **Note**: When `None` is used the type of `Option<T>` must be specified, because the compiler can't infer the type that the `Some` variant will hold by looking only at a `None` value.
+> **Note**: error values that have the `?` operator called on them go through the `from` function, defined in the `From` trait in the standard library, which is used to convert errors from one type into another
 
 ### Match Expressions
 
 A *match expression* is made up of *arms*. An arm consists of a *pattern* and the code that should be run if the value given to the beginning of the match expression fits that arm's pattern. Rust takes the value given to match and looks through each arm's pattern in turn.
 
-**NOTE**: `match` arms must be exhaustive for compilation.
+> **Note**: `match` arms must be exhaustive for compilation.
 
 ```rs
 enum Enum {
@@ -1169,7 +1169,7 @@ To enable multiple ownership, Rust has a type called `Rc<T>`, which is an abbrev
 The `Rc<T>` type keeps track of the number of references to a value to determine whether or not the value is still in use.  
 If there are zero references to a value, the value can be cleaned up without any references becoming invalid.
 
-**NOTE**: `Rc<T>` is only for use in single-threaded scenarios.
+> **Note**: `Rc<T>` is only for use in single-threaded scenarios.
 
 ```rs
 use std::rc::Rc;
@@ -1198,7 +1198,7 @@ For those reasons, checking the borrowing rules at compile time is the best choi
 The advantage of checking the borrowing rules at runtime instead is that certain memory-safe scenarios are then allowed, whereas they are disallowed by the compile-time checks.  
 Static analysis, like the Rust compiler, is inherently conservative.
 
-**NOTE**: `RefCell<T>` is only for use in single-threaded scenarios and will cause a compile-time error if used it in a multithreaded context.
+> **Note**: `RefCell<T>` is only for use in single-threaded scenarios and will cause a compile-time error if used it in a multithreaded context.
 
 When creating immutable and mutable references, the `&` and `&mut` syntax is used, respectively.  
 With `RefCell<T>`, the `borrow` and `borrow_mut` methods are ued, which are part of the safe API that belongs to `RefCell<T>`.  

docs/swift/swift.md

@@ -481,7 +481,7 @@ var obj = ClassName()  // obj instantiation
 
 Do actions before/after modifying a property value.
 
-**NOTE**: `willSet` and `didSet` do not *set* the value of the property.
+> **Note**: `willSet` and `didSet` do not *set* the value of the property.
 
 ```swift
 class ClassName {