TOML v1.0.0
===========

Tom's Obvious, Minimal Language.

par Tom Preston-Werner, Pradyun Gedam, etc.

Objectifs
---------

TOML est un format de fichier de configuration minimal facile à lire grâce à
une sémantique claire. Il est conçu pour correspondre sans ambiguïté à une
table de hachage et doit être facile à représenter dans de nombreux langages.

Sommaire
--------

- [Spécifications](#spécifications)
- [Commentaires](#commentaires)
- [Paire clé/valeur](#paire-clévaleur)
- [Clé](#clé)
- [Chaîne](#chaîne)
- [Entier](#entier)
- [Flottant](#flottant)
- [Booléen](#booléen)
- [Date-heure avec offset](#date-heure-avec-offset)
- [Date-heure locale](#date-heure-locale)
- [Date locale](#date-locale)
- [Heure locale](#heure-locale)
- [Tableau](#tableau)
- [Table](#table)
- [Table inline](#table-inline)
- [Tableau de table](#tableau-de-table)
- [Extension de nom de fichier](#extension-de-nom-de-fichier)
- [Type MIME](#type-mime)
- [Grammaire ABNF](#grammaire-abnf)


Spécifications
--------------

* TOML est sensible à la casse.
* Un fichier TOML doit être un document Unicode encodé UTF-8 valide.
* Espace blanc signifie tabulation (0x09) ou espace (0x20).
* Saut de ligne signifie LF (0x0A) ou CRLF (0x0D 0x0A).

Commentaires
------------

Un symbole dièse marque le reste de la ligne en tant que commentaire, sauf à
l'intérieur d'une chaîne de caractères.

```toml
# Ceci est un commentaire en ligne complète
key = "value" # Ceci est un commentaire en fin de ligne
other = "# Ceci n'est pas un commentaire"
```

Les caractères de contrôle autres que tabulation (U+0000 à U+0008, U+000A à
U+001F, U+007F) ne sont pas autorisés dans les commentaires.

Paire clé/valeur
----------------

Le bloc de construction principal d'un document TOML est la paire clé/valeur.

Les clés sont à gauche du signe égal et les valeurs sont à droite. Les espaces
blancs sont ignorés autour des noms et des valeurs de clé. La clé, le signe
égal et la valeur doivent être sur la même ligne (bien que certaines valeurs
puissent être réparties sur plusieurs lignes).

```toml
cle = "valeur"
```

Les valeurs doivent avoir l'un des types suivants.

- [Chaîne](#chaîne)
- [Entier](#entier)
- [Flottant](#flottant)
- [Booléen](#booléen)
- [Date-heure avec offset](#date-heure-avec-offset)
- [Date-heure locale](#date-heure-locale)
- [Date locale](#date-locale)
- [Heure locale](#heure-locale)
- [Tableau](#tableau)
- [Table inline](#table-inline)

Les valeurs non spécifiées ne sont pas valides.

```toml
cle = # INVALIDE
```

Il doit y avoir un saut de ligne (ou EOF) après une paire clé/valeur. (Voir
[Table inline](#table-inline) pour les exceptions.)

```toml
first = "Tom" last = "Preston-Werner" # INVALIDE
```

Clé
---

Une clé peut être nue, entre guillemets ou pointée.

**Les clés nues** ne peuvent contenir que des lettres ASCII, des chiffres
ASCII, des traits de soulignement et tirets (`A-Za-z0-9_-`). Notez que les
clés nues peuvent être composées uniquement de Chiffres ASCII, par ex. `1234`,
mais sont toujours interprétées comme des chaînes.

```toml
cle = "valeur"
bare_key = "valeur"
cle-nue = "valeur"
1234 = "valeur"
```

**Les clés entre guillemets** suivent exactement les mêmes règles que les
chaînes de base ou les littéraux et vous permettent d'utiliser un ensemble
beaucoup plus large de noms de clés. La meilleure pratique est d'utiliser les
clés nues sauf en cas d'absolue nécessité.

```toml
"127.0.0.1" = "valeur"
"encodage de caractères" = "valeur"
"ʎǝʞ" = "valeur"
'clé2' = "valeur"
'quoted "valeur"' = "valeur"
```

Une clé nue doit être non vide, mais une clé entre guillemets vide est
autorisée (bien que découragé).

```toml
= "pas de nom de clé" # INVALIDE
"" = "vide" # VALIDE mais déconseillé
'' = 'vide' # VALIDE mais déconseillé
```

**Les clés pointées** sont une séquence de clés nues ou entre guillemets
reliées par un point. Cela permet de regrouper des propriétés similaires :

```toml
name = "Orange"
physical.color = "orange"
physical.shape = "round"
site."google.com" = true
```

En JSON, cela vous donnerait la structure suivante :

```json
{
  "name": "Orange",
  "physical": {
    "color": "orange",
    "shape": "round"
  },
  "site": {
    "google.com": true
  }
}
```

Pour plus de détails sur les tables définies par les clés pointées,
reportez-vous à la section [Table](#table) ci-dessous.

Les espaces blancs autour des parties séparées par des points sont ignorés.
Cependant, la meilleure pratique consiste à ne pas utiliser d'espaces superflus.

```toml
fruit.name = "banane" # c'est la meilleure pratique
fruit. color = "jaune" # identique à fruit.color
fruit . flavor = "banane" # identique à fruit.flavor
```

L'indentation est traitée comme un espace et ignorée.

La définition d'une clé plusieurs fois n'est pas valide.

```toml
# NE FAITES PAS CELA
nom = "Tom"
nom = "Pradyun"
```

Notez que les clés nues et les clés entre guillemets sont équivalentes :

```toml
# CELA NE FONCTIONNERA PAS
orthographe = "favori"
"orthographe" = "favori"
```

Tant qu'une clé n'a pas été définie directement, vous pouvez toujours y écrire
et aux noms qu'il contient.

```toml
# Cela transforme la clé "fruit" en table.
fruit.apple.smooth = true

# Alors vous pouvez ajouter un élément à la table "fruit" comme ceci :
fruit.orange = 2
```

```toml
# CE QUI SUIT EST INVALIDE

# Ceci définit la valeur de fruit.apple comme un entier.
fruit.apple = 1

# Mais alors ceci traite fruit.apple comme si c'était une table.
# Vous ne pouvez pas transformer un entier en table.
fruit.apple.smooth = true # INVALIDE
```

Il est déconseillé de définir des clés pointées dans le désordre.

```toml
# VALIDE MAIS DÉCONSEILLÉ

apple.type = "fruit"
orange.type = "fruit"

apple.skin = "thin"
orange.skin = "thick"

apple.color = "red"
orange.color = "orange"
```

```toml
# RECOMMANDÉ

apple.type = "fruit"
apple.skin = "thin"
apple.color = "red"

orange.type = "fruit"
orange.skin = "thick"
orange.color = "orange"
```

Il est possible d'écrire les clés pointées qui ressemblent à des décimaux
mais qui sont des clés pointées en 2 parties. Ne faites pas ça à moins
d'avoir une bonne raison de le faire (et vous n'en avez probablement pas !).

```toml
3.14159 = "pi"
```

Le TOML ci-dessus correspond au JSON suivant.

```json
{ "3": { "14159": "pi" } }
```

Chaîne
------

Il existe quatre manières d'exprimer des chaînes de caractères : basique,
basique multi-ligne, littérale et littérale multi-ligne. Toutes les chaînes
doivent contenir uniquement des caractères UTF-8 valides.

**Les chaînes basiques** sont encadrées par des guillemets (`"`). Tout
caractère Unicode peut être utilisé à l'exception de ceux qui doivent être
échappés : guillemets, barre oblique inverse et les caractères de contrôle
autres que tabulation (U+0000 à U+0008, U+000A à U+001F, U+007F).

```toml
str = "Je suis une chaîne. \"Vous pouvez me citer\". Nom\tJos\u00E9\nEmplacement\tSF."
```

Pour plus de commodité, certains caractères populaires ont une séquence
d'échappement compacte.

```
\b - retour arrière (U+0008)
\t - tabulation (U+0009)
\n - saut de ligne (U+000A)
\f - saut de page (U+000C)
\r - retour chariot (U+000D)
\" - guillemet (U+0022)
\\ - barre oblique inverse (U+005C)
\uXXXX - unicode (U+XXXX)
\UXXXXXXXX - unicode (U+XXXXXXXX)
```

Tout caractère Unicode peut être échappé avec les formes `\uXXXX` ou
`\UXXXXXXXX`. Les codes d'échappement doivent être des [valeurs scalaires
Unicode](https://unicode.org/glossary/#unicode_scalar_value) valides.

Toutes les autres séquences d'échappement non répertoriées ci-dessus sont
réservées ; s'ils sont utilisés, TOML devrait produire une erreur.

Parfois, vous devez exprimer des passages de texte (par exemple, des fichiers
de traduction) ou voulez diviser une très longue chaîne en plusieurs lignes.
TOML rend cela facile.

**Les chaînes basiques multi-ligne** sont encadrées par trois guillemets de
part et d'autre, et autorisent les sauts de ligne. Un saut de ligne
immédiatement après le délimiteur d'ouverture sera supprimé. Tous les autres
caractères d'espace et de saut de ligne restent intacts.

```toml
str1 = """
Les roses sont rouges
Les violettes sont bleues"""
```

Les parseurs TOML peuvent choisir de normaliser le saut de ligne suivant ce
qui a du sens pour leur plate-forme.

```toml
# Sur un système Unix, la chaîne multi-ligne ci-dessus sera probablement la même que :
str2 = "Les roses sont rouges\nLes violettes sont bleues"

# Sur un système Windows, cela équivaudra probablement à :
str3 = "Les roses sont rouges\n\rLes violettes sont bleues"
```

Pour écrire de longues chaînes sans introduire d'espaces superflus, utilisez
une "barre oblique inverse" en fin de ligne. Lorsque le dernier caractère non
blanc sur une ligne est un `\` non échappé, il sera supprimé avec tous les
espaces (y compris les sauts de lignes) jusqu'au prochain caractère non blanc
ou délimiteur de fermeture. Toute les séquences d'échappement valables pour
les chaînes de base sont également valables pour les chaînes de base
multi-ligne.

```toml
# Les chaînes suivantes sont équivalentes octet par octet :
str1 = "The quick brown fox jumps over the lazy dog."

str2 = """
The quick brown \


  fox jumps over \
    the lazy dog."""

str3 = """\
       The quick brown \
       fox jumps over \
       the lazy dog.\
       """
```

Tout caractère Unicode peut être utilisé sauf ceux qui doivent être échappés :
barre oblique inverse et les caractères de contrôle autres que tabulation,
saut de ligne et retour chariot (U+0000 à U+0008, U+000B, U+000C, U+000E à
U+001F, U+007F).

Vous pouvez écrire un guillemet ou deux guillemets adjacents, n'importe où à
l'intérieur d'une chaîne de base multi-ligne. Ils peuvent également être écrits
juste à l'intérieur des délimiteurs.

```toml
str4 = """Voici deux guillemets : "". Assez simple."""
# str5 = """Voici trois guillemets : """.""" # INVALIDE
str5 = """Voici trois guillemets : ""\"."""
str6 = """Voici quinze guillemets : ""\"""\"""\"""\"""\"."""

# "Ceci," dit-elle, "est juste une déclaration inutile."
str7 = """"Ceci," dit-elle, "est juste une déclaration inutile.""""
```

Si vous spécifiez fréquemment des chemins Windows ou des expressions
régulières, devoir échapper avec les barres obliques inverses devient
rapidement fastidieux et source d'erreurs. TOML peut aider en prenant en
charge les chaînes littérales qui ne permettent pas du tout d'échapper.

**Les chaînes littérales** sont entourées de guillemets simples. Comme les
chaînes de base, elles doit apparaître sur une seule ligne :

```toml
# What you see is what you get.
winpath  = 'C:\Users\nodejs\templates'
winpath2 = '\\ServerX\admin$\system32\'
quoted   = 'Tom "Dubs" Preston-Werner'
regex    = '<\i\c*\s*>'
```

Comme il n'y a pas d'échappement, il n'y a aucun moyen d'écrire un guillemet
simple à l'intérieur d'une chaîne littérale entourée de guillemets simples.
Heureusement, TOML prend en charge une version multi-ligne des chaînes
littérales qui résout ce problème.

**Les chaînes littérales multi-ligne** sont entourées de trois guillemets
simples de chaque côté et autorisent les sauts lignes. Comme les chaînes
littérales, il n'y a aucun échappement possible. Un saut de ligne immédiatement
après le délimiteur d'ouverture sera supprimée. Tous le reste du contenu entre
les délimiteurs est interprété tel quel sans modification.

```toml
regex2 = '''I [dw]on't need \d{2} apples'''
lines  = '''
Le premier saut de ligne est
supprimé dans les chaînes littérales.
   Tous les autres espaces
   sont conservés.
'''
```

Vous pouvez écrire 1 ou 2 guillemets simples n'importe où dans une chaîne
littérale multi-ligne, mais les séquences de trois guillemets simples ou plus
ne sont pas autorisées.

```toml
quot15 = '''Ici il y a quinze guillemets: """""""""""""""'''

# apos15 = '''Ici il y a quinze guillemets simples: ''''''''''''''''''  # INVALID
apos15 = "Ici il y a quinze guillemets simples: '''''''''''''''"

# 'Cela,' dit-elle, 'est toujours inutile.'
str = ''''Cela,' dit-elle, 'est toujours inutile.''''
```

Les caractères de contrôle autres que la tabulation ne sont pas autorisés dans
une chaîne littérale. Ainsi, pour les données binaires, il est recommandé
d'utiliser Base64 ou un autre encodage ASCII ou UTF-8 approprié. La gestion de
cet encodage sera spécifique à l'application.

Entier
------

Les entiers positifs _peuvent être_ précédés d'un signe plus, les négatifs
_sont_ précédés d'un signe moins.

```toml
int1 = +99
int2 = 42
int3 = 0
int4 = -17
```

Pour les grands nombres, vous pouvez utiliser des traits de soulignement entre
les chiffres pour améliorer la lisibilité. Chaque trait de soulignement doit
être entouré d'au moins un chiffre sur chaque côté.

```toml
int5 = 1_000
int6 = 5_349_221
int7 = 53_49_221 # Regroupement du système de numérotation indien
int8 = 1_2_3_4_5 # VALIDE mais déconseillé
```

Les zéros non significatifs ne sont pas autorisés. Les valeurs entières `-0`
et `+0` sont valides et identique à un zéro sans préfixe.

Les valeurs entières positives peuvent également être exprimées en hexadécimal,
octal ou binaire. Dans ces formats, le `+` de début n'est pas autorisé et les
zéros de début sont autorisés (après le préfixe). Les valeurs hexadécimales
sont insensibles à la casse. Les traits de soulignement sont autorisés entre
les chiffres (mais pas entre le préfixe et la valeur).

```toml
# hexadécimal avec préfixe `0x`
hex1 = 0xDEADBEEF
hex2 = 0xdeadbeef
hex3 = 0xdead_beef

# octal avec préfixe `0o`
oct1 = 0o01234567
oct2 = 0o755 # utile pour les autorisations de fichiers Unix

# binaire avec préfixe `0b`
bin1 = 0b11010110
```

Les entiers signés de 64 bits (de −2^63 à 2^63−1) doivent être acceptés et
traités sans perte. Si un entier ne peut pas être représenté sans perte, cela
doit générer une erreur.

Flottant
--------

Les nombres à virgule flottante doivent être implémentés comme des valeurs
binary64 au sens IEEE 754.

Un flottant consiste d'une partie entière (qui respecte les mêmes règles que la
partie entière d'un décimal) suivie par une partie fractionnelle ou
exponentielle. Si les deux sont présentes, la partie fractionnelle doit
précéder la partie exponentielle.

```toml
# fractionnelle
flt1 = +1.0
flt2 = 3.1415
flt3 = -0.01

# exponentielle
flt4 = 5e+22
flt5 = 1e06
flt6 = -2E-2

# les deux
flt7 = 6.626e-34
```

Une partie fractionnelle est un point décimal suivi par au moins un chiffre.

Une partie exponentielle est un E (majuscule ou minuscule) suivi par une partie
entière (qui respecte les mêmes règles que la partie entière d'un décimal mais
peut inclure les 0 en tête).

Le point décimal, s'il est utilisé, doit être encadré par au moins un chiffre
de chaque côté.

```toml
# FLOTTANTS NON VALIDES
invalid_float_1 = .7
invalid_float_2 = 7.
invalid_float_3 = 3.e+20
```

Comme pour les entiers, vous pouvez utiliser des caractères de soulignement pour
améliorer la lisibilité. Chaque caractère de soulignement doit être entouré d'au
moins un chiffre.

```toml
flt8 = 224_617.445_991_228
```

Les valeurs flottantes `-0.0` et `+0.0` sont valides et devraient être acceptées
selon IEEE 754.

Des valeurs flottantes spéciales peuvent aussi être écrites. Elles sont
toujours en minuscule.

```toml
# infini
sf1 = inf  # infini positif
sf2 = +inf # infini positif
sf3 = -inf # infini négatif

# n'est pas un nombre (NaN)
sf4 = nan  # l'encodage réel sNaN/qNaN est spécifique à l'implémentation
sf5 = +nan # comme pour `nan`
sf6 = -nan # valide, l'encodage réel est spécifique à l'implémentation
```

Booléen
-------

Les booléens sont juste ceux auxquels vous êtes habitués. Toujours en
mincuscule.

```toml
bool1 = true
bool2 = false
```

Date-Heure avec offset
------------------------

Pour représenter un instant spécifique dans le temps, vous devez utiliser une
valeur date-heure avec offset selon la norme [RFC 3339](
https://tools.ietf.org/html/rfc3339).

```toml
odt1 = 1979-05-27T07:32:00Z
odt2 = 1979-05-27T00:32:00-07:00
odt3 = 1979-05-27T00:32:00.999999-07:00
```

Par souci de lisibilité, vous pouvez remplacer le délimiteur T entre la date et
l'heure par un espace (comme autorisé par la RFC 3339 section 5.6).

```toml
odt4 = 1979-05-27 07:32:00Z
```

Une précision à la milliseconde est requise. Une précision supplémentaire des
fractions de seconde est spécifique à l'implémentation. Si la valeur contient
une précision supérieure à celle que l'implémentation peut prendre en charge,
la précision supplémentaire doit être tronquée, pas arrondi.

Date-heure locale
-----------------

Si vous omettez l'offset d'une date-heure selon le format [RFC 3339](
https://tools.ietf.org/html/rfc3339), cela représente cette date-heure sans
relation avec un offset ou une timezone. Cela ne peut pas être converti en
instant sans information supplémentaire. La conversion en instant, si
nécessaire, est spécifique à l'implémentation.

```toml
ldt1 = 1979-05-27T07:32:00
ldt2 = 1979-05-27T00:32:00.999999
```

Une précision à la milliseconde est requise. Une précision supplémentaire des
fractions de seconde est spécifique à l'implémentation. Si la valeur contient
une précision supérieure à celle que l'implémentation peut prendre en charge,
la précision supplémentaire doit être tronquée, pas arrondi.

Date Locale
-----------

Si vous ne fournissez que le date d'une date-heure au format [RFC 3339](
https://tools.ietf.org/html/rfc3339), cela représentera le jour entier sans
relaton à un offset ou une timezone.

```toml
ld1 = 1979-05-27
```

Heure locale
------------

Si vous ne précisez que l'heure d'une date-heure au format [RFC 3339](
https://tools.ietf.org/html/rfc3339), cela représentera cete heure du jour sans
aucune relation avec une date, un offset ou une timezone

```toml
lt1 = 07:32:00
lt2 = 00:32:00.999999
```

Une précision à la milliseconde est requise. Une précision supplémentaire
des fractions de seconde est spécifique à l'implémentation. Si la valeur
contient une précision supérieure à celle que l'implémentation peut prendre
en charge, la précision supplémentaire doit être tronquée, pas arrondi.

Tableau
-------

Les tableaux sont des crochets avec des valeurs à l'intérieur. Les espaces
blancs sont ignorés. Les éléments sont séparés par des virgules. Ils peuvent
contenir des valeurs des mêmes types de données que ceux autorisés dans les
paires clé/valeur. Des valeurs de différents types peuvent être mélangées.

```toml
integers = [ 1, 2, 3 ]
colors = [ "red", "yellow", "green" ]
nested_arrays_of_ints = [ [ 1, 2 ], [3, 4, 5] ]
nested_mixed_array = [ [ 1, 2 ], ["a", "b", "c"] ]
string_array = [ "all", 'strings', """are the same""", '''type''' ]

# Les tableaux de type mixte sont autorisés
numbers = [ 0.1, 0.2, 0.5, 1, 2, 5 ]
contributors = [
  "Foo Bar <foo@example.com>",
  { name = "Baz Qux", email = "bazqux@example.com", url = "https://example.com/bazqux" }
]
```

Les tableaux peuvent s'étendre sur plusieurs lignes. Une virgule de fin est
autorisée après la dernière valeur du tableau. N'importe quel nombre de
nouvelles lignes et les commentaires peuvent précéder les valeurs, les virgules
et la parenthèse fermante. L'indentation entre les valeurs du tableau et les
virgules est traité comme un espace et ignoré.

```toml
integers2 = [
  1, 2, 3
]

integers3 = [
  1,
  2, # this is ok
]
```

Table
-----

Les tables (également appelées tables de hachage ou dictionnaires) sont des
collections de paires de clé/valeur. Ils sont définis par des en-têtes, avec
des crochets sur une ligne par eux-mêmes. Vous pouvez distinguer les en-têtes
de tables des tableaux car les tableaux ne sont que des valeurs.

```toml
[table]
```

En dessous, et jusqu'au prochain en-tête ou EOF, se trouvent les clés/valeurs
de cette table. Les paires clé/valeur dans les tables ne sont pas garanties
d'être dans un ordre spécifique.

```toml
[table-1]
key1 = "some string"
key2 = 123

[table-2]
key1 = "another string"
key2 = 456
```

Les règles de nommage pour les tables sont les mêmes que pour les clés (voir
la définition de [Clé](#clé) ci-dessus).

```toml
[dog."tater.man"]
type.name = "pug"
```

Dans en JSON, cela vous donnerait la structure suivante :

```json
{ "dog": { "tater.man": { "type": { "name": "pug" } } } }
```

Les espaces autour de la clé sont ignorés. Cependant, la meilleure pratique
consiste à ne pas utiliser d'espace superflu.

```toml
[a.b.c]            # this is best practice
[ d.e.f ]          # same as [d.e.f]
[ g .  h  . i ]    # same as [g.h.i]
[ j . "ʞ" . 'l' ]  # same as [j."ʞ".'l']
```

L'indentation est traitée comme un espace et ignorée.

Vous n'avez pas besoin de spécifier toutes les tables parentes si vous ne le
souhaitez pas. TOML sait comment le faire pour vous.

```toml
# [x] vous
# [x.y] n'avez pas
# [x.y.z] besoin de ça
[x.y.z.w] # pour que cela fonctionne

[x] # définir une table parente après coup est correct
```

Les tables vides sont autorisées et ne contiennent simplement aucune paire
clé/valeur.

Comme les clés, vous ne pouvez pas définir une table plus d'une fois. Le faire
est invalide.

```
# NE FAITES PAS CECI

[fruit]
apple = "red"

[fruit]
orange = "orange"
```

```
# ET ÇA NON PLUS

[fruit]
apple = "red"

[fruit.apple]
texture = "smooth"
```

Définir des tables dans le désordre est n'est pas recommandé.

```toml
# VALIDE MAIS NON RECOMMANDÉ
[fruit.apple]
[animal]
[fruit.orange]
```

```toml
# RECOMMANDÉ
[fruit.apple]
[fruit.orange]
[animal]
```

La table de niveau supérieur, également appelée table racine, commence au début
du document et se termine juste avant le premier en-tête de table (ou EOF).
Contrairement aux autres tables, il est sans nom et ne peut pas être déplacé.

```toml
# La table de niveau commence
name = "Fido"
breed = "pug"

# La table de niveau supérieur finit 
[owner]
name = "Regina Dogman"
member_since = 1999-08-04
```

Les clés pointées créent et définissent un tableau pour chaque partie de clé
avant la dernière, à condition que ces tables n'aient pas été préalablement
créées.

```toml
fruit.apple.color = "red"
# Définit une table nommée fruit
# Définit une table nommée fruit.apple

fruit.apple.taste.sweet = true
# Définit une table nommée fruit.apple.taste
# fruit et fruit.apple ont déjà été créées
```

Étant donné que les tables ne peuvent pas être définies plus d'une fois, la
redéfinition de ces tables à l'aide de l'en-tête `[table]` n'est pas autorisé.
De même, utiliser des clés pointées pour redéfinir les tables déjà définies
sous la forme `[table]` n'est pas autorisé. La forme `[table]` peut
cependant être utilisée pour définir des sous-tables dans des tables définies
via des touches pointées.

```toml
[fruit]
apple.color = "red"
apple.taste.sweet = true

# [fruit.apple]  # INVALIDE
# [fruit.apple.taste]  # INVALIDE

[fruit.apple.texture]  # vous pouvez ajouter des sous-tables
smooth = true
```

Table inline
------------

Les tables inline fournissent une syntaxe plus compacte pour exprimer les
tables. Elles sont particulièrement utiles pour les données regroupées qui
peuvent autrement devenir rapidement verbeuses. Les tables inline sont
entièrement définies entre accolades : `{` et `}`. Au sein des accolades, zéro
ou plusieurs paires clé/valeur séparées par des virgules peuvent apparaître.
Les paires clé/valeur prennent la même forme que les paires clé/valeur dans
les tables standard. Tous les types de valeur sont autorisés, y compris les
table inline.

Les tables inline sont destinées à apparaître sur une seule ligne. Une virgule
de fin n'est pas autorisée après la dernière paire clé/valeur dans une table
inline. Aucun saut de ligne n'est autorisé entre les accolades à moins
qu'elles ne soient valide dans une valeur. Même ainsi, il est fortement
déconseillé de casser une table inline sur plusieurs lignes. Si vous éprouvez
ce besoin, cela signifie que vous devriez utiliser des tables standard.

```toml
name = { first = "Tom", last = "Preston-Werner" }
point = { x = 1, y = 2 }
animal = { type.name = "pug" }
```

Les tables inline ci-dessus sont identiques aux tables standard suivantes :

```toml
[name]
first = "Tom"
last = "Preston-Werner"

[point]
x = 1
y = 2

[animal]
type.name = "pug"
```

Les tables inline sont entièrement autonomes et définissent toutes les clés
et sous-tables en elles-mêmes. Les clés et les sous-tables ne peuvent pas être
ajoutées en dehors des accolades.

```toml
[product]
type = { name = "Nail" }
# type.edible = false  # INVALIDE
```

De même, les tables inline ne peuvent pas être utilisées pour ajouter des clés
ou des sous-tables à une table déjà définie.

```toml
[product]
type.name = "Nail"
# type = { edible = false }  # INVALIDE
```

Tableau de table
----------------

La dernière syntaxe qui n'a pas encore été décrite permet d'écrire des
tableaux de tables. Ceux-ci peuvent être exprimés en utilisant un en-tête avec
un nom entre doubles crochets. La première instance de cet en-tête définit le
tableau et son premier élément de table, et chaque instance suivante crée et
définit un nouvel élément de table dans ce tableau. Les tables sont insérées
dans le tableau dans l'ordre rencontré.

```toml
[[products]]
name = "Hammer"
sku = 738594937

[[products]]  #table vide dans le tableau

[[products]]
name = "Nail"
sku = 284758393

color = "gray"
```

En JSON, cela donnerait la structure suivante :

```json
{
  "products": [
    { "name": "Hammer", "sku": 738594937 },
    { },
    { "name": "Nail", "sku": 284758393, "color": "gray" }
  ]
}
```

Toute référence à un tableau de tables pointe vers l'élément de table le plus
récemment défini du tableau. Cela vous permet de définir des sous-tables, et
même des sous-tableaux de tables, à l'intérieur de la table la plus récente.

```toml
[[fruits]]
name = "apple"

[fruits.physical]  # sous-table
color = "red"
shape = "round"

[[fruits.varieties]]  # tableau de tables imbriqué
name = "red delicious"

[[fruits.varieties]]
name = "granny smith"


[[fruits]]
name = "banana"

[[fruits.varieties]]
name = "plantain"
```

Le TOML ci-dessus produit le JSON suivant :

```json
{
  "fruits": [
    {
      "name": "apple",
      "physical": {
        "color": "red",
        "shape": "round"
      },
      "varieties": [
        { "name": "red delicious" },
        { "name": "granny smith" }
      ]
    },
    {
      "name": "banana",
      "varieties": [
        { "name": "plantain" }
      ]
    }
  ]
}
```

Si le parent d'une table ou d'un tableau de tables est un élément de tableau,
cet élément doit déjà avoir été défini avant que l'enfant puisse être défini.
Les tentatives d'inversion de cet ordre doivent produire une erreur au moment
de l'analyse.

```toml
# DOC TOML INVALIDE
[fruit.physical]  # sous-table, mais à quel élément parent doit-il appartenir ?
color = "red"
shape = "round"

[[fruit]]  # l'analyseur doit renvoyer une erreur en découvrant que
           # "fruit" est un tableau putôt d'une table
name = "apple"
```

Tenter d'ajouter à un tableau défini de manière statique, même si ce tableau
est vide, doit produire une erreur au moment de l'analyse.

```toml
# DOC TOML INVALIDE
fruits = []

[[fruits]] # non autorisé
```

Tenter de définir une table normale avec le même nom qu'un tableau déjà établi
doit produire une erreur au moment de l'analyse. Tenter de redéfinir une table
normale en tant que tableau doit également produire une erreur pendant
l'analyse.

```toml
# DOC TOML INVALIDE
[[fruits]]
name = "apple"

[[fruits.varieties]]
name = "red delicious"

# INVALIDE: Cette table entre en conflit le tableau de tables précédent
[fruits.varieties]
name = "granny smith"

[fruits.physical]
color = "red"
shape = "round"

# INVALIDE: Ce tableau de tables entre en conflit avec la table précédente
[[fruits.physical]]
color = "green"
```

Vous pouvez également utiliser des tableaux en ligne, le cas échéant :

```toml
points = [ { x = 1, y = 2, z = 3 },
           { x = 7, y = 8, z = 9 },
           { x = 2, y = 4, z = 8 } ]
```

Extension de nom de fichier
---------------------------

Les noms des fichiers TOML utilisent l'extension  `.toml`.

Type MIME
---------

Le type MIME d'un fichier TOML sur internet est `application/toml`.

Grammaire ABNF
--------------

Une description formelle de la syntaxe TOML est disponible sous la forme d'un [fichier ABNF][abnf] séparé.

[abnf]: https://github.com/toml-lang/toml/blob/1.0.0/toml.abnf