Translate missing WASM JS API pages (#3184)

8 files changed, 572 insertions, 0 deletions

diff --git a/files/fr/web/javascript/reference/global_objects/webassembly/compileerror/compileerror/index.md b/files/fr/web/javascript/reference/global_objects/webassembly/compileerror/compileerror/index.md
new file mode 100644
index 0000000000..525edbf09b
--- /dev/null
+++ b/files/fr/web/javascript/reference/global_objects/webassembly/compileerror/compileerror/index.md
@@ -0,0 +1,61 @@
+---
+title: Constructeur WebAssembly.CompileError()
+slug: Web/JavaScript/Reference/Global_Objects/WebAssembly/CompileError/CompileError
+translation_of: Web/JavaScript/Reference/Global_Objects/WebAssembly/CompileError/CompileError
+browser-compat: javascript.builtins.WebAssembly.CompileError.CompileError
+---
+{{JSRef}}
+
+Le constructeur **`WebAssembly.CompileError()`** crée un nouvel objet `CompileError` WebAssembly qui représente une erreur qui se produit lors du décodage ou de la validation du code WebAssembly.
+
+## Syntaxe
+
+```js
+new WebAssembly.CompileError()
+new WebAssembly.CompileError(message)
+new WebAssembly.CompileError(message, nomFichier)
+new WebAssembly.CompileError(message, nomFichier, numeroLigne)
+```
+
+### Paramètres
+
+- `message` {{optional_inline}}
+  - : Une description, compréhensible par un humain, de l'erreur.
+- `nomFichier` {{optional_inline}}
+  - : Le nom du fichier contenant le code qui a entraîné l'exception.
+- `numeroLigne` {{optional_inline}}
+  - : Le numéro de la ligne dans le fichier contenant le code qui a entraîné l'exception.
+
+## Exemples
+
+### Créer une nouvelle instance CompileError
+
+Le fragment de code qui suit crée une nouvelle instance de `CompileError` et affiche les détails correspondant dans la console :
+
+```js
+try {
+  throw new WebAssembly.CompileError('Coucou', 'unFichier', 10);
+} catch (e) {
+  console.log(e instanceof CompileError); // true
+  console.log(e.message);                 // "Coucou"
+  console.log(e.name);                    // "CompileError"
+  console.log(e.fileName);                // "unFichier"
+  console.log(e.lineNumber);              // 10
+  console.log(e.columnNumber);            // 0
+  console.log(e.stack);                   // renvoie l'emplacement du code exécuté
+}
+```
+
+## Spécifications
+
+{{Specifications}}
+
+## Compatibilité des navigateurs
+
+{{Compat}}
+
+## Voir aussi
+
+- La page  [WebAssembly](/fr/docs/WebAssembly)
+- [Concepts WebAssembly](/fr/docs/WebAssembly/Concepts)
+- [Utiliser l'API JavaScript WebAssembly](/fr/docs/WebAssembly/Using_the_JavaScript_API)
diff --git a/files/fr/web/javascript/reference/global_objects/webassembly/global/global/index.md b/files/fr/web/javascript/reference/global_objects/webassembly/global/global/index.md
new file mode 100644
index 0000000000..24193579d0
--- /dev/null
+++ b/files/fr/web/javascript/reference/global_objects/webassembly/global/global/index.md
@@ -0,0 +1,76 @@
+---
+title: Constructeur WebAssembly.Global()
+slug: Web/JavaScript/Reference/Global_Objects/WebAssembly/Global/Global
+translation_of: Web/JavaScript/Reference/Global_Objects/WebAssembly/Global/Global
+browser-compat: javascript.builtins.WebAssembly.Global.Global
+---
+{{JSRef}}
+
+Le constructeur **`WebAssembly.Global()`** permet de créer un nouvel objet `Global` représentant une instance d'une variable globale, accessible depuis le code JavaScript et importable/exportable dans plusieurs instances de [`WebAssembly.Module`](/fr/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Module). Cela permet la liaison dynamique de plusieurs modules.
+
+## Syntaxe
+
+```js
+new WebAssembly.Global(descripteur, valeur)
+```
+
+### Paramètres
+
+- _descripteur_
+
+  - : Un objet dictionnaire `GlobalDescriptor` qui contient deux propriétés :
+
+    - `value`: Une chaîne [`USVString`](/fr/docs/Web/API/USVString) représentant le type de données de la variable globale. Elle peut être `i32`, `i64`, `f32`, ou `f64`. `USVString` correspond à l'ensemble des différentes séquences Unicode scalaires possibles. `USVString` correspond à `String` lorsqu'il est renvoyé en JavaScript et est un type généralement utilisé par les API qui effectuent du traitement de texte et qui ont besoin de manipuler une chaîne de valeurs Unicode scalaire. `USVString` est équivalent à `DOMString` sauf qu'il n'accepte pas les codets surrogate non appairés. De tels caractères présents dans une valeur `USVString` seront convertis par le navigateur en caractères de remplacement Unicode : U+FFFD, (�).
+    - `mutable`: Une valeur booléenne qui indique si la variable globale est modifiable ou non. Par défaut, elle vaut `false`.
+
+- _valeur_
+  - : La valeur que contient la variable. Ce peut être n'importe quelle valeur dont le type correspond au type de données de la variable. Si aucune valeur n'est indiquée, c'est une valeur 0 typée qui est utilisée, comme indiqué dans [l'algorithme `DefaultValue`](https://webassembly.github.io/spec/js-api/#defaultvalue).
+
+## Exemples
+
+### Créer une nouvelle instance de Global
+
+L'exemple suivant illustre une nouvelle instance de variable globale créée avec le constructeur `WebAssembly.Global()`. Dans cet exemple, on définit une variable globale modifiable, de type `i32` avec une valeur initiale à 0.
+
+La valeur de la variable globale est ensuite changée : d'abord en `42` avec la propriété `Global.value`, puis en `43` avec la fonction `incGlobal()` qu'on a exportée du module `global.wasm` (cette fonction ajoute 1 à toute valeur qui lui est fournie et renvoie la valeur obtenue).
+
+```js
+const output = document.getElementById('output');
+
+function assertEq(msg, got, expected) {
+  output.innerHTML += `Test ${msg}: `;
+  if (got !== expected)
+    output.innerHTML += `ÉCHEC&nbsp;!<br>Résultat&nbsp; ${got}<br>Attendu&nbsp: ${expected}<br>`;
+  else
+    output.innerHTML += `SUCCÈS&nbsp;! Résultat&nbsp; ${got}<br>`;
+}
+
+assertEq("WebAssembly.Global existe", typeof WebAssembly.Global, "function");
+
+const global = new WebAssembly.Global({value:'i32', mutable:true}, 0);
+
+WebAssembly.instantiateStreaming(fetch('global.wasm'), { js: { global } })
+.then(({instance}) => {
+  assertEq("Obtenir une valeur initiale WASM", instance.exports.getGlobal(), 0);
+  global.value = 42;
+  assertEq("Obtenir une valeur mise à jour depuis le code JS", instance.exports.getGlobal(), 42);
+  instance.exports.incGlobal();
+  assertEq("Obtenir une valeur mise à jour depuis le code WASM", global.value, 43);
+});
+```
+
+> **Note :** Voir [l'exemple live sur GitHub](https://mdn.github.io/webassembly-examples/js-api-examples/global.html) et aussi [le code source](https://github.com/mdn/webassembly-examples/blob/master/js-api-examples/global.html).
+
+## Spécifications
+
+{{Specifications}}
+
+## Compatibilité des navigateurs
+
+{{Compat}}
+
+## Voir aussi
+
+- La page  [WebAssembly](/fr/docs/WebAssembly)
+- [Concepts WebAssembly](/fr/docs/WebAssembly/Concepts)
+- [Utiliser l'API JavaScript WebAssembly](/fr/docs/WebAssembly/Using_the_JavaScript_API)
diff --git a/files/fr/web/javascript/reference/global_objects/webassembly/instance/instance/index.md b/files/fr/web/javascript/reference/global_objects/webassembly/instance/instance/index.md
new file mode 100644
index 0000000000..dc05d48fe1
--- /dev/null
+++ b/files/fr/web/javascript/reference/global_objects/webassembly/instance/instance/index.md
@@ -0,0 +1,77 @@
+---
+title: Constructeur WebAssembly.Instance()
+slug: Web/JavaScript/Reference/Global_Objects/WebAssembly/Instance/Instance
+translation_of: Web/JavaScript/Reference/Global_Objects/WebAssembly/Instance/Instance
+browser-compat: javascript.builtins.WebAssembly.Instance.Instance
+---
+{{JSRef}}
+
+Le constructeur **`WebAssembly.Instance()`** crée un nouvel objet `Instance` qui représente une instance sans état et exécutable d'un [`WebAssembly.Module`](/fr/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Module).
+
+## Syntaxe
+
+> **Attention :** Étant donné que l'instanciation de grands modules peut être coûteuse, il est préférable d'utiliser le constructeur `Instance()` uniquement lorsqu'une instanciation synchrone est nécessaire. Par défaut et dans tous les autres cas, on privilégiera l'utilisation de la méthode asynchrone [`WebAssembly.instantiateStreaming()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/instantiateStreaming).
+
+```js
+new WebAssembly.Instance(module, importObject)
+```
+
+### Paramètres
+
+- _module_
+  - : L'objet [`WebAssembly.Module`](/fr/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Module) qu'on souhaite instancier.
+- _importObject_ {{optional_inline}}
+  - : Un objet contenant les valeurs à importer dans l'instance nouvellement créée telles que des fonctions ou des objets [`WebAssembly.Memory`](/fr/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Memory). Il doit y avoir une propriété correspondante pour chaque import déclaré de `module` ou une exception [`WebAssembly.LinkError`](/fr/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/LinkError) sera levée.
+
+## Exemples
+
+### Instancier un module WebAssembly de façon synchrone
+
+Le constructeur `WebAssembly.Instance()` peut être appelé de façon synchrone afin d'instancier un objet [`WebAssembly.Module`](/fr/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Module) donné, par exemple&nbsp;:
+
+```js
+const importObject = {
+  imports: {
+    imported_func: function(arg) {
+      console.log(arg);
+    }
+  }
+};
+
+fetch('simple.wasm').then(response =>
+  response.arrayBuffer()
+).then(bytes => {
+  let mod = new WebAssembly.Module(bytes);
+  let instance = new WebAssembly.Instance(mod, importObject);
+  instance.exports.exported_func();
+})
+```
+
+Toutefois, la méthode à privilégier pour obtenir une `Instance` est d'utiliser la fonction asynchrone [`WebAssembly.instantiateStreaming()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/instantiateStreaming) comme ceci&nbsp;:
+
+```js
+const importObject = {
+  imports: {
+    imported_func: function(arg) {
+      console.log(arg);
+    }
+  }
+};
+
+WebAssembly.instantiateStreaming(fetch('simple.wasm'), importObject)
+.then(obj => obj.instance.exports.exported_func());
+```
+
+## Spécifications
+
+{{Specifications}}
+
+## Compatibilité des navigateurs
+
+{{Compat}}
+
+## Voir aussi
+
+- La page  [WebAssembly](/fr/docs/WebAssembly)
+- [Concepts WebAssembly](/fr/docs/WebAssembly/Concepts)
+- [Utiliser l'API JavaScript WebAssembly](/fr/docs/WebAssembly/Using_the_JavaScript_API)
diff --git a/files/fr/web/javascript/reference/global_objects/webassembly/linkerror/linkerror/index.md b/files/fr/web/javascript/reference/global_objects/webassembly/linkerror/linkerror/index.md
new file mode 100644
index 0000000000..00387e4243
--- /dev/null
+++ b/files/fr/web/javascript/reference/global_objects/webassembly/linkerror/linkerror/index.md
@@ -0,0 +1,61 @@
+---
+title: Constructeur WebAssembly.LinkError()
+slug: Web/JavaScript/Reference/Global_Objects/WebAssembly/LinkError/LinkError
+translation_of: Web/JavaScript/Reference/Global_Objects/WebAssembly/LinkError/LinkError
+browser-compat: javascript.builtins.WebAssembly.LinkError.LinkError
+---
+{{JSRef}}
+
+Le constructeur **`WebAssembly.LinkError()`** crée un nouvel objet `LinkError` WebAssembly qui indique une erreur lors de l'instanciation du module (en dehors des [trapoess](https://webassembly.org/docs/semantics/#traps) de la fonction de départ).
+
+## Syntaxe
+
+```js
+new WebAssembly.LinkError()
+new WebAssembly.LinkError(message)
+new WebAssembly.LinkError(message, nomFichier)
+new WebAssembly.LinkError(message, nomFichier, numeroLigne)
+```
+
+### Paramètres
+
+- `message` {{optional_inline}}
+  - : Une description, compréhensible par un humain, de l'erreur.
+- `nomFichier` {{optional_inline}}
+  - : Le nom du fichier contenant le code qui a entraîné l'exception.
+- `numeroLigne` {{optional_inline}}
+  - : Le numéro de la ligne dans le fichier contenant le code qui a entraîné l'exception.
+
+## Exemples
+
+### Créer une nouvelle instance de LinkError
+
+Le fragment de code qui suit crée une nouvelle instance de `LinkError` et affiche les détails correspondant dans la console&nbsp;:
+
+```js
+try {
+  throw new WebAssembly.LinkError('Coucou', 'unFichier', 10);
+} catch (e) {
+  console.log(e instanceof LinkError); // true
+  console.log(e.message);                 // "Coucou"
+  console.log(e.name);                    // "LinkError"
+  console.log(e.fileName);                // "unFichier"
+  console.log(e.lineNumber);              // 10
+  console.log(e.columnNumber);            // 0
+  console.log(e.stack);                   // renvoie l'emplacement du code exécuté
+}
+```
+
+## Spécifications
+
+{{Specifications}}
+
+## Compatibilité des navigateurs
+
+{{Compat}}
+
+## Voir aussi
+
+- La page  [WebAssembly](/fr/docs/WebAssembly)
+- [Concepts WebAssembly](/fr/docs/WebAssembly/Concepts)
+- [Utiliser l'API JavaScript WebAssembly](/fr/docs/WebAssembly/Using_the_JavaScript_API)
diff --git a/files/fr/web/javascript/reference/global_objects/webassembly/memory/memory/index.md b/files/fr/web/javascript/reference/global_objects/webassembly/memory/memory/index.md
new file mode 100644
index 0000000000..9222aea5e6
--- /dev/null
+++ b/files/fr/web/javascript/reference/global_objects/webassembly/memory/memory/index.md
@@ -0,0 +1,85 @@
+---
+title: Constructeur WebAssembly.Memory()
+slug: Web/JavaScript/Reference/Global_Objects/WebAssembly/Memory/Memory
+translation_of: Web/JavaScript/Reference/Global_Objects/WebAssembly/Memory/Memory
+browser-compat: javascript.builtins.WebAssembly.Memory.Memory
+---
+{{JSRef}}
+
+Le constructeur **`WebAssembly.Memory()`** permet de créer un nouvel objet `Memory` dont la propriété [`buffer`](/fr/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Memory/buffer) est un tableau tampon [`ArrayBuffer`](/fr/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer) redimensionnable ou un `SharedArrayBuffer` contenant les octets bruts de mémoire à laquelle accède une `Instance` WebAssembly.
+
+Une mémoire créée par du code JavaScript ou WebAssembly sera accessible et modifiable depuis JavaScript ou WebAssembly.
+
+## Syntaxe
+
+```js
+new WebAssembly.Memory(descripteurMemoire)
+```
+
+### Paramètres
+
+- _descripteurMemoire_
+
+  - : Un objet contenant les propriétés suivantes&nbsp;:
+
+    - `initial`
+      - : La taille initiale de la mémoire WebAssembly Memory, exprimée en nombre de pages WebAssembly.
+    - `maximum` {{optional_inline}}
+      - : La taille maximale que peut atteindre la mémoire WebAssembly, exprimée en nombre de pages WebAssembly. Lorsque ce paramètre est présent, il peut être utilisé comme indication par le moteur afin de réserver la mémoire d'avance. Toutefois, le moteur pourra ignorer cette réservation ou l'effectuer avec une taille moindre. Les mémoires WebAssembly qui ne sont pas partagées n'ont pas besoin de définir une propriété `maximum`, en revanche, c'est une propriété nécessaire pour les mémoires partagées.
+    - `shared` {{optional_inline}}
+      - : Une valeur booléenne qui définit si la mémoire est partagée ou non. Si elle vaut `true`, il s'agira d'une mémoire partagée. La valeur par défaut est `false`.
+
+> **Note :** Une page WebAssembly mesure une taille constante de 65&nbsp;536 octets, soit 64Ko.
+
+### Exceptions
+
+- Si `descripteurMemoire` n'est pas un objet, une exception [`TypeError`](/fr/docs/Web/JavaScript/Reference/Global_Objects/TypeError) sera levée.
+- Si `maximum` est indiqué et est inférieur à `initial`, une exception [`RangeError`](/fr/docs/Web/JavaScript/Reference/Global_Objects/RangeError) sera levée.
+
+## Exemples
+
+### Créer une nouvelle instance Memory
+
+Il existe deux façons d'obtenir un objet `WebAssembly.Memory`. La première consiste à la construire depuis du code JavaScript. Dans l'exemple qui suit, on crée une nouvelle instance d'un objet `Memory` WebAssembly avec une taille initiale de 10 pages (640Ko) et une taille maximale de 100 pages (6,4Mo). Sa propriété [`buffer`](/fr/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Memory/buffer) renverra un objet [`ArrayBuffer`](/fr/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer).
+
+```js
+var memory = new WebAssembly.Memory({initial:10, maximum:100});
+```
+
+La deuxième méthode pour obtenir un objet `WebAssembly.Memory` consiste à l'exporter depuis un module WebAssembly. Dans l'exemple suivant (voir [memory.html](https://github.com/mdn/webassembly-examples/blob/master/js-api-examples/memory.html) sur GitHub pour le code source, ainsi que [la démonstration correspondante](https://mdn.github.io/webassembly-examples/js-api-examples/memory.html)), on récupère et on instancie le bytecode chargé memory.wasm avec la méthode [`WebAssembly.instantiateStreaming()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/instantiateStreaming) tout en important la mémoire créée à la ligne précédente. On stocke ensuite certaines valeurs dans cette mémoire et on exporte une fonction qu'on utilise pour additionner certaines des valeurs.
+
+```js
+WebAssembly.instantiateStreaming(fetch('memory.wasm'), { js: { mem: memory } })
+.then(obj => {
+  var i32 = new Uint32Array(memory.buffer);
+  for (var i = 0; i < 10; i++) {
+    i32[i] = i;
+  }
+  var sum = obj.instance.exports.accumulate(0, 10);
+  console.log(sum);
+});
+```
+
+### Créer une mémoire partagée
+
+Par défaut, les mémoires WebAssembly ne sont pas partagées. On peut créer une [mémoire partagée](/fr/docs/WebAssembly/Understanding_the_text_format) en passant `shared: true` dans l'objet d'initialisation du constructeur&nbsp;:
+
+```js
+let memory = new WebAssembly.Memory({initial:10, maximum:100, shared:true});
+```
+
+La propriété `buffer` de l'objet mémoire correspondant renverra alors un objet [`SharedArrayBuffer`](/fr/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer).
+
+## Spécifications
+
+{{Specifications}}
+
+## Compatibilité des navigateurs
+
+{{Compat}}
+
+## Voir aussi
+
+- La page  [WebAssembly](/fr/docs/WebAssembly)
+- [Concepts WebAssembly](/fr/docs/WebAssembly/Concepts)
+- [Utiliser l'API JavaScript WebAssembly](/fr/docs/WebAssembly/Using_the_JavaScript_API)
diff --git a/files/fr/web/javascript/reference/global_objects/webassembly/module/module/index.md b/files/fr/web/javascript/reference/global_objects/webassembly/module/module/index.md
new file mode 100644
index 0000000000..e0392428a7
--- /dev/null
+++ b/files/fr/web/javascript/reference/global_objects/webassembly/module/module/index.md
@@ -0,0 +1,66 @@
+---
+title: Constructeur WebAssembly.Module()
+slug: Web/JavaScript/Reference/Global_Objects/WebAssembly/Module/Module
+translation_of: Web/JavaScript/Reference/Global_Objects/WebAssembly/Module/Module
+browser-compat: javascript.builtins.WebAssembly.Module.Module
+---
+{{JSRef}}
+
+Le constructeur **`WebAssembly.Module()`** crée un nouvel objet `Module` contenant du code WebAssembly sans état qui a déjà été compilé par le navigateur et qui peut efficacement [être partagé avec des workers](/fr/docs/Web/API/Worker/postMessage) et être instancié plusieurs fois.
+
+Le constructeur `WebAssembly.Module()` peut être appelé de façon synchrone afin de compiler le code binaire WebAssembly correspondant. Toutefois, la méthode principale pour obtenir un `Module` consiste à utiliser une fonction de compilation asynchrone comme [`WebAssembly.compile()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/compile).
+
+## Syntaxe
+
+> **Attention :** Étant donné que la compilation de grands modules peut être coûteuse, il est préférable d'utiliser `Module()` uniquement lorsqu'une compilation synchrone est nécessaire. Dans tous les autres cas, on privilégiera la méthode [`WebAssembly.compileStreaming()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/compileStreaming).
+
+```js
+new WebAssembly.Module(bufferSource)
+```
+
+### Parameters
+
+- _bufferSource_
+  - : Un [tableau typé](/fr/docs/Web/JavaScript/Typed_arrays) ou un [`ArrayBuffer`](/fr/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer) contenant le code binaire du module .wasm qu'on souhaite compiler.
+
+## Exemples
+
+### Compiler un module WebAssembly de façon synchrone
+
+```js
+var importObject = {
+  imports: {
+    imported_func: function(arg) {
+      console.log(arg);
+    }
+  }
+};
+
+function createWasmModule(bytes) {
+  return new WebAssembly.Module(bytes);
+}
+
+fetch('simple.wasm').then(response =>
+  response.arrayBuffer()
+).then(bytes => {
+  let mod = createWasmModule(bytes);
+  WebAssembly.instantiate(mod, importObject)
+  .then(result =>
+     result.exports.exported_func()
+  );
+})
+```
+
+## Spécifications
+
+{{Specifications}}
+
+## Compatibilité des navigateurs
+
+{{Compat}}
+
+## Voir aussi
+
+- La page  [WebAssembly](/fr/docs/WebAssembly)
+- [Concepts WebAssembly](/fr/docs/WebAssembly/Concepts)
+- [Utiliser l'API JavaScript WebAssembly](/fr/docs/WebAssembly/Using_the_JavaScript_API)
diff --git a/files/fr/web/javascript/reference/global_objects/webassembly/runtimeerror/runtimeerror/index.md b/files/fr/web/javascript/reference/global_objects/webassembly/runtimeerror/runtimeerror/index.md
new file mode 100644
index 0000000000..fe25de9ec7
--- /dev/null
+++ b/files/fr/web/javascript/reference/global_objects/webassembly/runtimeerror/runtimeerror/index.md
@@ -0,0 +1,61 @@
+---
+title: Constructeur WebAssembly.RuntimeError()
+slug: Web/JavaScript/Reference/Global_Objects/WebAssembly/RuntimeError/RuntimeError
+translation_of: Web/JavaScript/Reference/Global_Objects/WebAssembly/RuntimeError/RuntimeError
+browser-compat: javascript.builtins.WebAssembly.RuntimeError.RuntimeError
+---
+{{JSRef}}
+
+Le constructeur **`WebAssembly.RuntimeError()`** crée un nouvel objet `RuntimeError` WebAssembly, une erreur levée quand WebAssembly définit une [trappe](https://webassembly.org/docs/semantics/#traps).
+
+## Syntaxe
+
+```js
+new WebAssembly.RuntimeError()
+new WebAssembly.RuntimeError(message)
+new WebAssembly.RuntimeError(message, nomFichier)
+new WebAssembly.RuntimeError(message, nomFichier, numeroLigne)
+```
+
+### Paramètres
+
+- `message` {{optional_inline}}
+  - : Une description, compréhensible par un humain, de l'erreur.
+- `nomFichier` {{optional_inline}}
+  - : Le nom du fichier contenant le code qui a entraîné l'exception.
+- `numeroLigne` {{optional_inline}}
+  - : Le numéro de la ligne dans le fichier contenant le code qui a entraîné l'exception.
+
+## Exemples
+
+### Créer une nouvelle instance de RuntimeError
+
+Le fragment de code qui suit crée une nouvelle instance de `RuntimeError` puis affiche ses informations dans la console&nbsp;:
+
+```js
+try {
+  throw new WebAssembly.RuntimeError('Coucou', 'unFichier', 10);
+} catch (e) {
+  console.log(e instanceof WebAssembly.RuntimeError); // true
+  console.log(e.message);                             // "Coucou"
+  console.log(e.name);                                // "RuntimeError"
+  console.log(e.fileName);                            // "unFichier"
+  console.log(e.lineNumber);                          // 10
+  console.log(e.columnNumber);                        // 0
+  console.log(e.stack);                               // renvoie l'emplacement du code exécuté
+}
+```
+
+## Spécifications
+
+{{Specifications}}
+
+## Compatibilité des navigateurs
+
+{{Compat}}
+
+## Voir aussi
+
+- La page  [WebAssembly](/fr/docs/WebAssembly)
+- [Concepts WebAssembly](/fr/docs/WebAssembly/Concepts)
+- [Utiliser l'API JavaScript WebAssembly](/fr/docs/WebAssembly/Using_the_JavaScript_API)
diff --git a/files/fr/web/javascript/reference/global_objects/webassembly/table/table/index.md b/files/fr/web/javascript/reference/global_objects/webassembly/table/table/index.md
new file mode 100644
index 0000000000..55ee827e0e
--- /dev/null
+++ b/files/fr/web/javascript/reference/global_objects/webassembly/table/table/index.md
@@ -0,0 +1,85 @@
+---
+title: Constructeur WebAssembly.Table()
+slug: Web/JavaScript/Reference/Global_Objects/WebAssembly/Table/Table
+translation_of: Web/JavaScript/Reference/Global_Objects/WebAssembly/Table/Table
+browser-compat: javascript.builtins.WebAssembly.Table.Table
+---
+{{JSRef}}
+
+Le constructeur **`WebAssembly.Table()`** crée un nouvel objet `Table` de la taille et du type d'élément donné.
+
+## Syntaxe
+
+```js
+new WebAssembly.Table(descripteurTable)
+```
+
+### Paramètres
+
+- _descripteurTable_
+
+  - : Un objet qui peut contenir les propriétés suivantes&nbsp;:
+
+    - `element`
+      - : Une chaîne de caractères représentant le type de valeur à stocker dans la table. Pour le moment, sa valeur ne peut être que `"anyfunc"` (indiquant les fonctions).
+    - `initial`
+      - : Le nombre initial d'éléments dans la table WebAssembly.
+    - _maximum {{optional_inline}}_
+      - : Le nombre maximal d'éléments jusqu'auquel la table WebAssembly peut grandir.
+
+### Exceptions
+
+- Si `descripteurTable` n'est pas un objet, une exception [`TypeError`](/fr/docs/Web/JavaScript/Reference/Global_Objects/TypeError) sera levée.
+- Si `maximum` est fourni et est inférieur à `initial`, une exception [`RangeError`](/fr/docs/Web/JavaScript/Reference/Global_Objects/RangeError) sera levée.
+
+## Exemples
+
+### Créer une nouvelle instance d'une Table WebAssembly
+
+Dans l'exemple suivant (voir [le code source](https://github.com/mdn/webassembly-examples/blob/master/js-api-examples/table2.html) et [la démo live ](https://mdn.github.io/webassembly-examples/js-api-examples/table2.html) correspondants), on crée une nouvelle instance d'une table WebAssembly avec une taille initiale de 2 éléments. On affiche alors la longueur de la table et son contenu (grâce à [`Table.prototype.get()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Table/get) pour montrer que la longueur vaut 2 et que les deux éléments sont [`null`](/fr/docs/Web/JavaScript/Reference/Global_Objects/null).
+
+```js
+var tbl = new WebAssembly.Table({initial:2, element:"anyfunc"});
+console.log(tbl.length);  // "2"
+console.log(tbl.get(0));  // "null"
+console.log(tbl.get(1));  // "null"
+```
+
+On peut ensuite créer un objet d'import qui contient la table&nbsp;:
+
+```js
+var importObj = {
+  js: {
+    tbl:tbl
+  }
+};
+```
+
+Enfin, on charge et on instancie un module WASM (table2.wasm) en utilisant la méthode [`WebAssembly.instantiateStreaming()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/instantiateStreaming). Le module table2.wasm contient deux fonctions (une qui renvoie 42 et l'autre qui renvoie 83) et on stocke ces deux fonctions dans les éléments 0 et 1 de la table importée (voir [la représentation textuelle](https://github.com/mdn/webassembly-examples/blob/master/js-api-examples/table2.wat)).  Ainsi, après l'instanciation, la table a toujours une longueur qui vaut 2 et les éléments contiennent désormais [des fonctions WebAssembly exportées](/fr/docs/WebAssembly/Exported_functions) qu'on peut appeler depuis le code JavaScript.
+
+```js
+WebAssembly.instantiateStreaming(fetch('table2.wasm'), importObject)
+.then(function(obj) {
+  console.log(tbl.length);
+  console.log(tbl.get(0)());
+  console.log(tbl.get(1)());
+});
+```
+
+On notera qu'il faut inclure une deuxième paire de parenthèses afin d'invoquer la fonction référencée et d'afficher la valeur qui y est stockée (on écrit donc `get(0)()` plutôt que `get(0)`) .
+
+Dans cet exemple, on illustre la création et l'accès à la table depuis du code JavaScript, mais cette même table est visible depuis l'instance WASM également.
+
+## Spécifications
+
+{{Specifications}}
+
+## Compatibilité des navigateurs
+
+{{Compat}}
+
+## Voir aussi
+
+- La page  [WebAssembly](/fr/docs/WebAssembly)
+- [Concepts WebAssembly](/fr/docs/WebAssembly/Concepts)
+- [Utiliser l'API JavaScript WebAssembly](/fr/docs/WebAssembly/Using_the_JavaScript_API)