diff --git a/docs/classes-emit.md b/docs/classes-emit.md
index 7cf1a8cb5..4014a0ea1 100644
--- a/docs/classes-emit.md
+++ b/docs/classes-emit.md
@@ -55,20 +55,20 @@ var __extends = this.__extends || function (d, b) {
 ここで `d`は派生クラスを指し、`b`はベースクラスを指します。この関数は2つのことを行います：
 
 1. 親クラスの静的メンバを子クラスにコピーする:`for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];`
-1. 子クラス関数のプロトタイプを準備し、任意に親の`proto`のメンバを検索できるようにする。つまり、`d.prototype.__ proto__ = b.prototype`を実現する
+1. 子クラス関数のプロトタイプを準備し、任意に親の`proto`のメンバを検索できるようにする。つまり、`d.prototype.__proto__ = b.prototype`を実現する
 
 1を理解するのに苦労する人はほとんどいませんが、2については多くの人が理解に苦労します。なので順番に説明します。
 
-#### `d.prototype .__ proto__ = b.prototype`
+#### `d.prototype.__proto__ = b.prototype`
 
-これについて多くの人を教えた結果、次のような説明が最もシンプルだと分かりました。まず、`__extends`のコードが、単純な`d.prototype .__ proto__ = b.prototype`とどうして同じなのか、そしてなぜ、この行それ自体が重要であるのかを説明します。これをすべて理解するためには、これらのことを理解する必要があります:
+これについて多くの人を教えた結果、次のような説明が最もシンプルだと分かりました。まず、`__extends`のコードが、単純な`d.prototype.__proto__ = b.prototype`とどうして同じなのか、そしてなぜ、この行それ自体が重要であるのかを説明します。これをすべて理解するためには、これらのことを理解する必要があります:
 
 1. `__proto__`
 1. `prototype`
 1. `new`の関数の内側の`this`に対する効果
 1. `new`の`prototype`と`__proto__`に対する効果
 
-JavaScriptのすべてのオブジェクトは `__proto__`メンバを含んでいます。このメンバは古いブラウザではアクセスできないことがよくあります(ドキュメントでは、この魔法のプロパティを `[[prototype]]`と呼ぶことがあります)。それは1つの目的を持っています：検索しているプロパティがオブジェクトに見つからない場合(例えば `obj.property`)、`obj .__ proto __.property`を検索します。それでもまだ見つからなければ、 `obj .__ proto __.__ proto __.property`を検索します： それが見つかるか、最後の`.__ proto__`自体が`null`となるまで続きます。これは、JavaScriptが*プロトタイプ継承*(prototypal inheritance)をサポートしていることを説明しています。次の例でこれを示します。chromeコンソールまたはNode.jsで実行することが可能です。
+JavaScriptのすべてのオブジェクトは `__proto__`メンバを含んでいます。このメンバは古いブラウザではアクセスできないことがよくあります(ドキュメントでは、この魔法のプロパティを `[[prototype]]`と呼ぶことがあります)。それは1つの目的を持っています：検索しているプロパティがオブジェクトに見つからない場合(例えば `obj.property`)、`obj.__proto__.property`を検索します。それでもまだ見つからなければ、 `obj.__proto__.__proto__.property`を検索します： それが見つかるか、最後の`.__proto__`自体が`null`となるまで続きます。これは、JavaScriptが*プロトタイプ継承*(prototypal inheritance)をサポートしていることを説明しています。次の例でこれを示します。chromeコンソールまたはNode.jsで実行することが可能です。
 
 ```ts
 var foo = {}
@@ -121,11 +121,11 @@ console.log(foo.__proto__ === Foo.prototype); // True!
 3   d.prototype = new __();
 ```
 
-この関数を逆から見ると、3行目の`d.prototype = new __()`は、 `d.prototype = {__proto__：__.prototype}`を意味します(`prototype`と`__proto__`に対する`new`の効果によるものです)。それを2行目(`__.prototype = b.prototype;`)と組み合わせると、`d.prototype = {__proto__：b.prototype}`となります。
+この関数を逆から見ると、3行目の`d.prototype = new __()`は、 `d.prototype = {__proto__ : __.prototype}`を意味します(`prototype`と`__proto__`に対する`new`の効果によるものです)。それを2行目(`__.prototype = b.prototype;`)と組み合わせると、`d.prototype = {__proto__ : b.prototype}`となります。
 
-しかし、待ってください。私達は、単に`d.prototype.__proto__`が変更され、`d.prototype.constructor`は、それまで通り維持されることを望んでいました。そこで重要な意味があるのが、最初の行(`function __(){this.constructor = d;}`)です。これは`d.prototype = {__proto__：__.prototype, constructor：d}`を実現できます(これは関数の内側の`this`に対する`new`による効果のためです)。したがって`d.prototype.constructor`を復元しているので、我々が変更したものは、`__proto__`たった1つだけであり、それゆえ`d.prototype.__proto__ = b.prototype`となります。
+しかし、待ってください。私達は、単に`d.prototype.__proto__`が変更され、`d.prototype.constructor`は、それまで通り維持されることを望んでいました。そこで重要な意味があるのが、最初の行(`function __() { this.constructor = d; }`)です。これは`d.prototype = {__proto__ : __.prototype, constructor : d}`を実現できます(これは関数の内側の`this`に対する`new`による効果のためです)。したがって`d.prototype.constructor`を復元しているので、我々が変更したものは、`__proto__`たった1つだけであり、それゆえ`d.prototype.__proto__ = b.prototype`となります。
 
-#### `d.prototype.__ proto__ = b.prototype`の意味
+#### `d.prototype.__proto__ = b.prototype`の意味
 
 これを行うことによって、子クラスにメンバ関数を追加しつつ、その他のメンバは基本クラスから継承することができます。次の簡単な例で説明します:
 
@@ -141,4 +141,4 @@ var bird = new Bird();
 bird.walk();
 bird.fly();
 ```
-基本的に`bird.fly`は`bird.__ proto __.fly`(`new`は`bird.__proto__`が`Bird.prototype`を指すようにすることを思い出してください)から検索され、`bird.walk`(継承されたメンバー)は`bird.__proto__.__proto__.walk`から検索されます(`bird.__proto__ == Bird.prototype`、そして、`bird.__proto __.__proto__` == `Animal.prototype`です)。
+基本的に`bird.fly`は`bird.__proto__.fly`(`new`は`bird.__proto__`が`Bird.prototype`を指すようにすることを思い出してください)から検索され、`bird.walk`(継承されたメンバー)は`bird.__proto__.__proto__.walk`から検索されます(`bird.__proto__ == Bird.prototype`、そして、`bird.__proto__.__proto__` == `Animal.prototype`です)。
diff --git a/docs/classes.md b/docs/classes.md
index 2efb7865f..674a1639d 100644
--- a/docs/classes.md
+++ b/docs/classes.md
@@ -142,7 +142,7 @@ class Foo {
     }
 }
 ```
-これはTypeScriptの省略形を使うことができる一般的なパターンです。メンバにアクセス修飾子を付けることができ、それが自動的にクラス内に宣言され、コンストラクタからコピーされます。なので、前の例は次のように書き直すことが可能です(`public x：number`に注目してください)：
+これはTypeScriptの省略形を使うことができる一般的なパターンです。メンバにアクセス修飾子を付けることができ、それが自動的にクラス内に宣言され、コンストラクタからコピーされます。なので、前の例は次のように書き直すことが可能です(`public x:number`に注目してください)：
 
 ```ts
 class Foo {
diff --git a/docs/compiler/ast.md b/docs/compiler/ast.md
index 1d15a6a0d..4c072abd3 100644
--- a/docs/compiler/ast.md
+++ b/docs/compiler/ast.md
@@ -5,7 +5,7 @@ ASTノードのドキュメントを構成するものは、２つのキーと
 
 いくつかの主要な `interface Node`のメンバがあります：
 * ソースファイル内のノードの`start`と`end`を識別する`TextRange`メンバ
-* ASTの中でノードの親となる`parent ?: Node`
+* ASTの中でノードの親となる`parent?: Node`
 
 `Node`のフラグと修飾子のために、いくつか他のメンバがあります。あなたはソースコード中で`interface Node`を検索することで見つけることができます。しかし、上記で言及したものは、ノードトラバーサル(node traversal)のために不可欠です。
 
diff --git a/docs/compiler/binder-declarations.md b/docs/compiler/binder-declarations.md
index 3575a597c..e29a82546 100644
--- a/docs/compiler/binder-declarations.md
+++ b/docs/compiler/binder-declarations.md
@@ -1,7 +1,7 @@
 ### SymbolとDeclaration
 `node`と`symbol`の間のリンクは、いくつかの関数によって実行されます。ある1つの関数は、`SourceFile`NodeをSource File Symbolにバインドするために使われます。それは、`addDeclarationToSymbol`関数です。
 
-注：外部モジュールソースファイルの`Symbol`は`flags ： SymbolFlags.ValueModule`と`name： '"' + removeFileExtension(file.fileName) + '"'`)としてセットアップされています。
+注：外部モジュールソースファイルの`Symbol`は`flags : SymbolFlags.ValueModule`と`name: '"' + removeFileExtension(file.fileName) + '"'`)としてセットアップされています。
 
 ```ts
 function addDeclarationToSymbol(symbol: Symbol, node: Declaration, symbolFlags: SymbolFlags) {
diff --git a/docs/compiler/checker-global.md b/docs/compiler/checker-global.md
index 694b50ec5..7c82b31e5 100644
--- a/docs/compiler/checker-global.md
+++ b/docs/compiler/checker-global.md
@@ -10,4 +10,4 @@ forEach(host.getSourceFiles(), file => {
 });
 ```
 
-これは基本的にすべての`global`Symbolを`let globals：SymbolTable = {};`(`createTypeChecker`にあります)SymbolTableにマージします。`mergeSymbolTable`は主に`mergeSymbol`を呼び出します。
+これは基本的にすべての`global`Symbolを`let globals: SymbolTable = {};`(`createTypeChecker`にあります)SymbolTableにマージします。`mergeSymbolTable`は主に`mergeSymbol`を呼び出します。
diff --git a/docs/compiler/overview.md b/docs/compiler/overview.md
index f64b2d917..7c89fde57 100644
--- a/docs/compiler/overview.md
+++ b/docs/compiler/overview.md
@@ -52,7 +52,7 @@ TypeScriptコンパイラには、これらの主要部分にユーティリテ
 ## File: Utilities
 `core.ts`：TypeScriptコンパイラが使うコアユーティリティ。いくつか重要なもの：
 
-* `let objectAllocator：ObjectAllocator`：シングルトンのグローバルとして定義された変数です。それは、`getNodeConstructor`(Nodeは`parser`/`AST`を見るときに扱います)、`getSymbolConstructor`(シンボルは`binder`のときに扱います)、`getTypeConstructor`(型は`checker`で扱います)、 `getSignatureConstructor`(シグネチャはインデックス、シグネチャの呼び出しと構成物です)。
+* `let objectAllocator: ObjectAllocator`：シングルトンのグローバルとして定義された変数です。それは、`getNodeConstructor`(Nodeは`parser`/`AST`を見るときに扱います)、`getSymbolConstructor`(シンボルは`binder`のときに扱います)、`getTypeConstructor`(型は`checker`で扱います)、 `getSignatureConstructor`(シグネチャはインデックス、シグネチャの呼び出しと構成物です)。
 
 ## File： 主要なデータ構造
 `types.ts`には、コンパイラ全体で使用される、主要なデータ構造とインタフェースがあります。いくつかの重要なサンプルの抜粋です：
diff --git a/docs/compiler/parser-functions.md b/docs/compiler/parser-functions.md
index a209fae82..fc5af29cf 100644
--- a/docs/compiler/parser-functions.md
+++ b/docs/compiler/parser-functions.md
@@ -24,10 +24,10 @@ function parseEmptyStatement(): Statement {
 これは、3つの重要な関数`createNode`、`parseExpected`と`finishNode`を示しています。
 
 #### `createNode`
-Parserの`createNode`関数`function createNode(kind：SyntaxKind、pos ?: number)：Node`はノードの作成、渡されたときの`SyntaxKind`のセットアップ、渡された場合の初期位置の設定(または、現在のスキャナの位置を使います)を行います。
+Parserの`createNode`関数`function createNode(kind: SyntaxKind, pos?: number): Node`はノードの作成、渡されたときの`SyntaxKind`のセットアップ、渡された場合の初期位置の設定(または、現在のスキャナの位置を使います)を行います。
 
 #### `parseExpected`
-Parserの`parseExpected`関数`function parseExpected(kind：SyntaxKind、diagnosticMessage ?: DiagnosticMessage)：boolean`は、Parserの状態に含まれる現在のトークンが目的の`SyntaxKind`と一致することをチェックします。そうでなければ、送られた`diagnosticMessage`を報告するか、`foo expected`の形式の一般的なものを作成します。これは内部的に`parseErrorAtPosition`関数(スキャン位置を使用します)を使用して良いエラー報告を行います。
+Parserの`parseExpected`関数`function parseExpected(kind: SyntaxKind, diagnosticMessage?: DiagnosticMessage): boolean`は、Parserの状態に含まれる現在のトークンが目的の`SyntaxKind`と一致することをチェックします。そうでなければ、送られた`diagnosticMessage`を報告するか、`foo expected`の形式の一般的なものを作成します。これは内部的に`parseErrorAtPosition`関数(スキャン位置を使用します)を使用して良いエラー報告を行います。
 
 ### `finishNode`
-Parserの`finishNode`関数`function finishNode <T extends Node>(node：T、end ?:: number)：T`はNodeの`end`位置や、`parserContextFlags`のように便利なモノを設定します。これは、このNodeを解析する前にエラーがあったとしても、同じようにパースされます(その場合、インクリメンタルパーシングでこのASTノードを再利用できません)。
+Parserの`finishNode`関数`function finishNode<T extends Node>(node: T, end?: number): T`はNodeの`end`位置や、`parserContextFlags`のように便利なモノを設定します。これは、このNodeを解析する前にエラーがあったとしても、同じようにパースされます(その場合、インクリメンタルパーシングでこのASTノードを再利用できません)。
diff --git a/docs/compiler/program.md b/docs/compiler/program.md
index 8d78fff66..29b64ad4e 100644
--- a/docs/compiler/program.md
+++ b/docs/compiler/program.md
@@ -14,4 +14,4 @@ OEとの相互作用メカニズムを示します：
 
 ### ソースファイル
 
-programは、ソースファイルを取得するためのAPI`getSourceFiles()：SourceFile [];`を提供します。それぞれは、ASTのルートレベルのノード(`SourceFile`と呼ばれます)として表されます。
+programは、ソースファイルを取得するためのAPI`getSourceFiles(): SourceFile[];`を提供します。それぞれは、ASTのルートレベルのノード(`SourceFile`と呼ばれます)として表されます。
diff --git a/docs/generators.md b/docs/generators.md
index 41dc01976..0d86fb109 100644
--- a/docs/generators.md
+++ b/docs/generators.md
@@ -22,7 +22,7 @@ while (true) {
 }
 ```
 
-もちろんイテレータが終了した場合は、以下に示すように`{done：true}`の結果を得られます。
+もちろんイテレータが終了した場合は、以下に示すように`{ done: true }`の結果を得られます。
 
 ```ts
 function* idMaker(){
diff --git a/docs/jsx/others.md b/docs/jsx/others.md
index 1f87a443f..b0513d927 100644
--- a/docs/jsx/others.md
+++ b/docs/jsx/others.md
@@ -2,16 +2,16 @@
 
 TypeScriptは、React with JSX以外のものをタイプセーフな方法で使用する機能を提供します。以下は、カスタマイズ可能なポイントを示していますが、これは高度なUIフレームワークの作成者向けです。
 
-* `"jsx" ： "preserve"`オプションを使って`react`形式の出力を無効にすることができます。これは、JSXが*そのままの状態で*出力されることを意味します。そして、あなた自身のカスタムトランスパイラを使用してJSX部分をトランスパイルすることができます
+* `"jsx" : "preserve"`オプションを使って`react`形式の出力を無効にすることができます。これは、JSXが*そのままの状態で*出力されることを意味します。そして、あなた自身のカスタムトランスパイラを使用してJSX部分をトランスパイルすることができます
 * `JSX`グローバルモジュールを使う：
     * `JSX.IntrinsicElements`インターフェースのメンバをカスタマイズすることで、どのHTMLタグが利用可能で、どのように型チェックされるかを制御することができます。
     * コンポーネントを使用する場合：
-        *デフォルトの`Interface ElementClass extends React.Component <any any> {}`宣言をカスタマイズすることによって、どのクラスがコンポーネントによって継承されなければならないかを制御できます
-        * どのプロパティが属性(デフォルトは`props`)の型チェックに使われるかを制御できます。`declare module JSX {interface ElementAttributesProperty {props：{};}`の宣言をカスタマイズすることで行います。
+        *デフォルトの`interface ElementClass extends React.Component<any, any> { }`宣言をカスタマイズすることによって、どのクラスがコンポーネントによって継承されなければならないかを制御できます
+        * どのプロパティが属性(デフォルトは`props`)の型チェックに使われるかを制御できます。`declare module JSX { interface ElementAttributesProperty { props: {}; } }`の宣言をカスタマイズすることで行います。
 
 ## `jsxFactory`
 
-`--jsxFactory <JSX factory name>`と `--jsx react`を一緒に渡すことで、デフォルトの`React`とは別のJSXファクトリを使うことができます。
+`--jsxFactory <JSX factory Name>`と `--jsx react`を一緒に渡すことで、デフォルトの`React`とは別のJSXファクトリを使うことができます。
 
 新しいファクトリ名は`createElement`関数を呼び出すために使われます。
 
diff --git a/docs/jsx/react.md b/docs/jsx/react.md
index 4ac4ab5cf..b1c459f96 100644
--- a/docs/jsx/react.md
+++ b/docs/jsx/react.md
@@ -7,7 +7,7 @@
 私たちの[ブラウザ向けのクイックスタートに、すでにReactアプリケーションの開発のセットアップの仕方を説明しています](../quick/browser.md)。主なハイライトは次の通りです。
 
 * ファイル拡張子`.tsx`(`.ts`の代わりに)を使用してください。
-* あなたの`tsconfig.json`の`compilerOptions`で `"jsx" ： "react"を使ってください。
+* あなたの`tsconfig.json`の`compilerOptions`で `"jsx" : "react"`を使ってください。
 * JSXとReactの定義をあなたのプロジェクトにインストールします：(`npm i -D @types/react @types/react-dom`)。
 * reactを`.tsx`ファイルにインポートします(`import * as React from "react"`となります)。
 
diff --git a/docs/jsx/tsx.md b/docs/jsx/tsx.md
index 0b8aa1110..f2f763777 100644
--- a/docs/jsx/tsx.md
+++ b/docs/jsx/tsx.md
@@ -8,6 +8,6 @@ JSXの背景にある動機は、ユーザーがHTMLのようなビューをJava
 
 * あなたのJavaScriptと同じようにビューの型チェックをすること
 * ビューを操作するコンテキストを認識させる(つまり、従来のMVCでの*controller-view*の接続を強化する)。
-* HTMLのメンテナンスに、JavaScriptパターン(`Array.prototype.map`、`？： `、`switch`など)を(新しい代替(おそらくほとんど型付けされない)を作成する代わりに)再利用する。
+* HTMLのメンテナンスに、JavaScriptパターン(`Array.prototype.map`、`?:`、`switch`など)を(新しい代替(おそらくほとんど型付けされない)を作成する代わりに)再利用する。
 
 これにより、エラーの可能性が減り、ユーザーインターフェースの保守性が向上します。現時点でのJSXの主なユーザは[ReactJS from facebook](http://facebook.github.io/react/)です。ここではJSXの使い方について説明します。
diff --git a/docs/options/strictNullChecks.md b/docs/options/strictNullChecks.md
index 6aa442e2a..381ee97f1 100644
--- a/docs/options/strictNullChecks.md
+++ b/docs/options/strictNullChecks.md
@@ -26,7 +26,7 @@ interface Member {
 }
 ```
 
-全ての`メンバー`が彼らの年齢を提供するわけではないので、`age`はオプションのプロパティです。 `age`の値は`undefined`かもしれません。
+全ての`Member`が彼らの年齢を提供するわけではないので、`age`はオプションのプロパティです。 `age`の値は`undefined`かもしれません。
 
 `undefined`はすべての悪の根です。ランタイムエラーが発生することがよくあります。実行時に`Error`をスローするコードを書くのは簡単です：
 
diff --git a/docs/project/external-modules.md b/docs/project/external-modules.md
index f3987fcbf..d31bd2259 100644
--- a/docs/project/external-modules.md
+++ b/docs/project/external-modules.md
@@ -11,7 +11,7 @@ TypeScriptの外部モジュールパターンには大きなパワーと利便
 * SystemJS：良い実験でした。ESモジュールによって置き換えられました
 * ESモジュール：まだ使えません
 
-これはJavaScriptを生成するためのオプションです。これらのオプションの代わりに、`module：commonjs`を使ってください。
+これはJavaScriptを生成するためのオプションです。これらのオプションの代わりに、`module:commonjs`を使ってください。
 
 どのようにTypeScriptモジュールを書くかについても、ちょっと混乱があります。今日それを避けるには:
 
@@ -19,7 +19,7 @@ TypeScriptの外部モジュールパターンには大きなパワーと利便
 
 クール!ではESモジュールの構文を見てみましょう。
 
-> 概要： `module：commonjs`を使い、ESモジュール構文を使ってモジュールをimport/export/作成します。
+> 概要： `module:commonjs`を使い、ESモジュール構文を使ってモジュールをimport/export/作成します。
 
 ### ESモジュールの構文
 
@@ -124,7 +124,7 @@ import someLocalNameForThisFile from "../foo";
 
 ### モジュールのパス
 
-> 私は`moduleResolution：commonjs`を仮定しています。これはあなたのTypeScript設定に含めるべきオプションです。この設定は`module：commonjs`によって暗黙的に設定されます。
+> 私は`moduleResolution: commonjs`を仮定しています。これはあなたのTypeScript設定に含めるべきオプションです。この設定は`module:commonjs`によって暗黙的に設定されます。
 
 2つの異なる種類のモジュールがあります。この区別は、import文のパスセクション(path section)によって行われます(たとえば、`import foo from 'これがパスセクションです'`)。
 
diff --git a/docs/project/files.md b/docs/project/files.md
index 5da9a58f8..87f339b46 100644
--- a/docs/project/files.md
+++ b/docs/project/files.md
@@ -27,4 +27,4 @@
 
 メモ：
 
-* グロブ(globs)の場合：`**/*`(例えば、サンプル使用法 `somefolder/**/*`)はすべてのフォルダとファイルを意味します(`.ts`/`.tsx`拡張子が対象になります。`allowJs：true`を設定した場合は`.js`/`.jsx`)。
+* グロブ(globs)の場合：`**/*`(例えば、サンプル使用法 `somefolder/**/*`)はすべてのフォルダとファイルを意味します(`.ts`/`.tsx`拡張子が対象になります。`allowJs:true`を設定した場合は`.js`/`.jsx`)。
diff --git a/docs/project/module-resolution.md b/docs/project/module-resolution.md
index 03a5b0f6e..524353729 100644
--- a/docs/project/module-resolution.md
+++ b/docs/project/module-resolution.md
@@ -4,7 +4,7 @@ TypeScriptのモジュール解決は、実際のモジュールシステム/ロ
 
 ## ファイル拡張子
 
-`foo`や`。/ foo`のようなモジュールをインポートします。任意のファイルパス検索のために、TypeScriptはコンテキストに応じて `.ts`または`.d.ts`または `.tsx`または`.js`(オプション)または `.jsx`(オプション)ファイルを正しい順序で自動的にチェックします。モジュール名をファイル拡張子で指定しないでください( `foo.ts`、`foo`だけではありません)。
+`foo`や`./foo`のようなモジュールをインポートします。任意のファイルパス検索のために、TypeScriptはコンテキストに応じて `.ts`または`.d.ts`または `.tsx`または`.js`(オプション)または `.jsx`(オプション)ファイルを正しい順序で自動的にチェックします。モジュール名をファイル拡張子で指定しないでください( `foo.ts`、`foo`だけではありません)。
 
 ## 相対ファイルモジュール
 
@@ -14,7 +14,7 @@ TypeScriptのモジュール解決は、実際のモジュールシステム/ロ
 import foo = require('./foo');
 ```
 
-TypeScriptコンパイラに相対位置でTypeScriptファイルを探すように指示します。現在のファイルに対して `。/ foo.ts`を実行します。この種の輸入にはそれ以上の魔法はありません。もちろん、それはより長い経路にすることができる。 `。/ foo / bar / bas`や`../../../ foo / bar / bas`のように他の*相対パスと同じように*あなたはディスク上で慣れています。
+TypeScriptコンパイラに相対位置でTypeScriptファイルを探すように指示します。現在のファイルに対して `./foo.ts`を実行します。この種の輸入にはそれ以上の魔法はありません。もちろん、それはより長い経路にすることができる。 `./foo/bar/bas`や`../../../foo/bar/bas`のように他の*相対パスと同じように*あなたはディスク上で慣れています。
 
 ## 名前付きモジュール
 
@@ -30,7 +30,7 @@ TypeScriptコンパイラに、次の順序で外部モジュールを検索す
 * まだ解決されておらず、 `--module commonjs`でコンパイルしているか、`--moduleResolution node`を設定している場合は、[* node modules *](#node-modules)解決アルゴリズムを使って調べます。
 * まだ解決されず、 `baseUrl`(オプションで`paths`)を指定した場合、[* path substitutions *](#path-substitution)解決アルゴリズムが起動します。
 
-``foo '`はより長いパス文字列にすることができます。 ``foo / bar / bas "`となります。ここでの鍵は、 `。/`や `../`*で始まらないことです。
+`"foo"`はより長いパス文字列にすることができます。 `"foo/bar/bas"`となります。ここでの鍵は、 `./`や `../`*で始まらないことです。
 
 ## モジュール宣言
 
@@ -50,7 +50,7 @@ declare module "foo" {
 ## ノードモジュール
 ノードモジュールの解像度は、Node.js / NPM([official nodejs docs](https://nodejs.org/api/modules.html#modules_all_together))で使用されている解像度とほぼ同じです。ここに私が持っているシンプルな精神モデルがあります：
 
-* モジュール `foo / bar`はいくつかのファイルに解決されます：`node_modules / foo`(モジュール)+ `foo / bar`
+* モジュール `foo/bar`はいくつかのファイルに解決されます：`node_modules / foo`(モジュール)+ `foo/bar`
 
 ## パスの置換
 
diff --git a/docs/project/namespaces.md b/docs/project/namespaces.md
index 93035f325..e2d0bc5b5 100644
--- a/docs/project/namespaces.md
+++ b/docs/project/namespaces.md
@@ -9,7 +9,7 @@
 })(something || (something = {}))
 ```
 
-基本的に、`something || (something = {})`は、無名関数`function(something) {}`が何かを既存オブジェクト(`something ||`部分)に追加するか、新しいオブジェクト( `||(something = {})`の部分)を作って何かを追加することを可能にします。これが意味することは、このように何らかの分岐で分割された2つのブロックを持つことができるということです。
+基本的に、`something || (something = {})`は、無名関数`function(something) {}`が何かを既存オブジェクト(`something ||`部分)に追加するか、新しいオブジェクト( `|| (something = {})`の部分)を作って何かを追加することを可能にします。これが意味することは、このように何らかの分岐で分割された2つのブロックを持つことができるということです。
 
 ```ts
 (function(something) {
diff --git a/docs/quick/nodejs.md b/docs/quick/nodejs.md
index 6194771f5..7b04ff9de 100644
--- a/docs/quick/nodejs.md
+++ b/docs/quick/nodejs.md
@@ -8,7 +8,7 @@ TypeScriptは、Node.jsを公式にサポートしています。素早くNode.j
 1. `node.d.ts`を追加する(`npm install @types/node --save-dev`)
 1. TypeScriptの設定ファイル`tsconfig.json`をいくつかの重要なオプションを使って初期化する(`npx tsc --init --rootDir src --outDir lib --esModuleInterop --resolveJsonModule --lib es6,dom --module commonjs`)。
 
-それでおしまい!あなたのIDE(例えば`code .`)を起動して遊んでください。TypeScriptの安全性と開発者人間工学とあわせて、組み込みのすべてのノードモジュールを使用することができます(例：`import fs = require( 'fs');`)。
+それでおしまい!あなたのIDE(例えば`code .`)を起動して遊んでください。TypeScriptの安全性と開発者人間工学とあわせて、組み込みのすべてのノードモジュールを使用することができます(例：`import * as fs from 'fs';`)。
 
 ## ボーナス： ライブコンパイル+実行
 * nodeでのライブコンパイル+実行のために使う`ts-node`を追加する(`npm install ts-node --save-dev`)
@@ -58,11 +58,11 @@ package
 
 * `tsconfig.json`について
   * `compilerOptions`に`"outDir": "lib"`と、`"declaration": true`を設定します < これは宣言ファイルとjsファイルをlibフォルダに生成します
-  * `"include"：["./src / ** / *"]`を設定します < これは`src`ディレクトリからのすべてのファイルを対象に含めます
+  * `"include": ["./src / ** / *"]`を設定します < これは`src`ディレクトリからのすべてのファイルを対象に含めます
 
 * `package.json`について
-  * `"main"： "lib/index"` <これはNode.jsに`lib/index.js`をロードするように指示します
-  * `"types"： "lib/index"` <これはTypeScriptに`lib/index.d.ts`をロードするように指示します
+  * `"main": "lib/index"` <これはNode.jsに`lib/index.js`をロードするように指示します
+  * `"types": "lib/index"` <これはTypeScriptに`lib/index.d.ts`をロードするように指示します
 
 
 パッケージの例：
diff --git a/docs/staging/generators.md b/docs/staging/generators.md
index 01200919c..cb47fa97a 100644
--- a/docs/staging/generators.md
+++ b/docs/staging/generators.md
@@ -58,4 +58,4 @@ catch(ex) {
 #### 外部で関数の実行を制御する
 ジェネレータ関数から返されたイテレータは、ジェネレータ関数の状態*を制御するためにも使用できます。
 
-// TODO：example
+// TODO: example
diff --git a/docs/styleguide/styleguide.md b/docs/styleguide/styleguide.md
index c8f8a4718..eb2f5ae27 100644
--- a/docs/styleguide/styleguide.md
+++ b/docs/styleguide/styleguide.md
@@ -170,7 +170,7 @@ let foo = {x:123,y:undefined};
 let foo:{x:number,y?:number} = {x:123};
 ```
 
-* 一般的に `undefined`を使用してください(代わりに`{valid：boolean、value？：Foo} `のようなオブジェクトを返すことを検討してください)
+* 一般的に `undefined`を使用してください(代わりに`{valid:boolean,value?:Foo}`のようなオブジェクトを返すことを検討してください)
 
 ***悪い***
 ```ts
@@ -253,7 +253,7 @@ const foo: string = "hello";
 
 ## 配列
 
-* 配列に`foos：Array<Foo>`の代わりに`foos：Foo[]`として配列にアノテーションをつけます。
+* 配列に`foos:Array<Foo>`の代わりに`foos:Foo[]`として配列にアノテーションをつけます。
 
 > 理由：読みやすい。TypeScriptチームによって使用されています。脳が`[]`を検出するように訓練されているので、何かが配列であることを知りやすくなります。
 
diff --git a/docs/tips/build-toggles.md b/docs/tips/build-toggles.md
index 942976792..22a7b8e6b 100644
--- a/docs/tips/build-toggles.md
+++ b/docs/tips/build-toggles.md
@@ -9,7 +9,7 @@
 "build:prod": "webpack -p --define process.env.NODE_ENV='\"production\"' --config ./src/webpack.config.js",
 ```
 
-もちろん、あなたは`npm install webpack --save-dev`を行っていることを前提にしています。これで`npm run build：test`などを実行できます。
+もちろん、あなたは`npm install webpack --save-dev`を行っていることを前提にしています。これで`npm run build:test`などを実行できます。
 
 この変数を使うのも簡単です：
 
diff --git a/docs/tips/jquery.md b/docs/tips/jquery.md
index 7e95e4317..03c874a43 100644
--- a/docs/tips/jquery.md
+++ b/docs/tips/jquery.md
@@ -12,4 +12,4 @@ interface JQuery {
 }
 ```
 
-そして、あなたは`$('something').foo({whateverYouWant：'hello jquery plugin'})`を使うことができます。
+そして、あなたは`$('something').foo({whateverYouWant:'hello jquery plugin'})`を使うことができます。
diff --git a/docs/tips/nominalTyping.md b/docs/tips/nominalTyping.md
index a01de30c2..cad19d6e4 100644
--- a/docs/tips/nominalTyping.md
+++ b/docs/tips/nominalTyping.md
@@ -39,7 +39,7 @@ foo = foo; // Okay
 
 この回避策には、以下が含まれます。
 * 種類を表すenumを作成する
-* enumと実際の構造の(intersection `＆`)としての型を作成する
+* enumと実際の構造の(intersection `&`)としての型を作成する
 
 下記のデモで示します。その構造の型はただの文字列です:
 
diff --git a/docs/tips/typeInstantiation.md b/docs/tips/typeInstantiation.md
index 4c21d183e..bc1c2a7f2 100644
--- a/docs/tips/typeInstantiation.md
+++ b/docs/tips/typeInstantiation.md
@@ -8,7 +8,7 @@ class Foo<T>{
 }
 ```
 
-特定の型の特殊バージョンを作成したいとします。このパターンは、項目を新しい変数にコピーし、ジェネリックを具体的な型に置き換えた型アノテーションを与えることです。例えば。 `Foo <number>`クラスが必要な場合です：
+特定の型の特殊バージョンを作成したいとします。このパターンは、項目を新しい変数にコピーし、ジェネリックを具体的な型に置き換えた型アノテーションを与えることです。例えば。 `Foo<number>`クラスが必要な場合です：
 
 ```ts
 class Foo<T>{
diff --git a/docs/types/advanced.md b/docs/types/advanced.md
index 2b0ec02a8..fcc830e58 100644
--- a/docs/types/advanced.md
+++ b/docs/types/advanced.md
@@ -5,7 +5,7 @@
 # 関数
 
 ## オプション
-`？ 'アノテーションは、メンバがオプションであることを示すために、関数の引数またはインタフェースのメンバの前に使用できます。つまり、あなたが望むならそれを提供することができます(そしてそれはタイプチェックされます)。しかし、それが省略されていれば* okay *です。これは次の例に示されています。
+`?`アノテーションは、メンバがオプションであることを示すために、関数の引数またはインタフェースのメンバの前に使用できます。つまり、あなたが望むならそれを提供することができます(そしてそれはタイプチェックされます)。しかし、それが省略されていれば* okay *です。これは次の例に示されています。
 
 ## 特殊化されたパラメータ
 
@@ -44,7 +44,7 @@ getOrSet(1); // set : 1
 console.log(getOrSet()); // get : 1
 ```
 
-関数のオーバーロードをこのように定義すると、最後のシグネチャは実際にはコール可能ではないことに注意してください*。しかし、機能の実装者が彼の過負荷署名の結果を認識するのを助けるために、それを提供しなければなりません。たとえば、次の例では、 `function callMe(v1 ?: any、v2 ?: any)：any`という署名を持つ関数は公開されていません。
+関数のオーバーロードをこのように定義すると、最後のシグネチャは実際にはコール可能ではないことに注意してください*。しかし、機能の実装者が彼の過負荷署名の結果を認識するのを助けるために、それを提供しなければなりません。たとえば、次の例では、 `function callMe(v1?: any, v2?: any): any`という署名を持つ関数は公開されていません。
 
 ```ts
 function callMe(): number;
diff --git a/docs/types/exceptions.md b/docs/types/exceptions.md
index a0d46a514..96a5bea3d 100644
--- a/docs/types/exceptions.md
+++ b/docs/types/exceptions.md
@@ -157,7 +157,7 @@ function validate(value: number) {
 }
 ```
 
-このような場合に`Error`を使うのは、validate関数の型定義(`(value：number)=> void`)で表現されていないので、悪い考えです。代わりに、検証メソッドを作成するためのより良い方法は次のとおりです。
+このような場合に`Error`を使うのは、validate関数の型定義(`(value:number) => void`)で表現されていないので、悪い考えです。代わりに、検証メソッドを作成するためのより良い方法は次のとおりです。
 
 ```ts
 function validate(value: number): {error?: string} {
diff --git a/docs/types/freshness.md b/docs/types/freshness.md
index 5247cf20c..919aa448f 100644
--- a/docs/types/freshness.md
+++ b/docs/types/freshness.md
@@ -29,7 +29,7 @@ logName({ name: 'matt' }); // okay
 logName({ name: 'matt', job: 'being awesome' }); // Error: object literals must only specify known properties. `job` is excessive here.
 ```
 
-このエラーはオブジェクトリテラルでのみ発生することに注意してください。このエラーがなければ、`logName({name： 'matt', job： 'awesome'})`という呼び出しを見て、logNameが`job`を渡すと何かを便利なことを実行すると思うかもしれません。現実的には完全に無視されます。
+このエラーはオブジェクトリテラルでのみ発生することに注意してください。このエラーがなければ、`logName({ name: 'matt', job: 'being awesome' })`という呼び出しを見て、logNameが`job`を渡すと何かを便利なことを実行すると思うかもしれません。現実的には完全に無視されます。
 
 もう1つの大きなユースケースは、オプションのメンバを持つインターフェイスで、このようなオブジェクトのリテラルチェックなしでは、型チェックはタイプミスを見逃します。これは以下のとおりです：
 
diff --git a/docs/types/functions.md b/docs/types/functions.md
index c31f89cd7..1df74f9f8 100644
--- a/docs/types/functions.md
+++ b/docs/types/functions.md
@@ -16,7 +16,7 @@ function foo(sampleParameter: { bar: number }) { }
 
 ### 戻り値の型アノテーション
 
-戻り値の型には、変数に使用するのと同じスタイルの関数パラメータリストの後にアノテーションを付けることができます。`：Foo`の例です：
+戻り値の型には、変数に使用するのと同じスタイルの関数パラメータリストの後にアノテーションを付けることができます。`: Foo`の例です：
 
 ```ts
 interface Foo {
@@ -53,7 +53,7 @@ function foo() {
 sendAsJSON(foo());
 ```
 
-関数から何かを返す予定がないなら、`：void`とアノテーションを付けることができます。通常、`：void`を書かずに型推論に任せることができます。
+関数から何かを返す予定がないなら、`:void`とアノテーションを付けることができます。通常、`:void`を書かずに型推論に任せることができます。
 
 ### オプションパラメータ
 パラメータをオプションとしてマークすることができます：
diff --git a/docs/types/generics.md b/docs/types/generics.md
index 85f738a22..314863fde 100644
--- a/docs/types/generics.md
+++ b/docs/types/generics.md
@@ -158,7 +158,7 @@ const getJSON = <T>(config: {
   }
 ```
 
-あなたは依然としてアノテーションを明示しなければならないことに注意してください。しかし、`getJSON<T>`のシグネチャ`(config)=> Promise <T>`は、キータイプを減らすことができます(`loadUsers`の戻り値の型は、TypeScriptが推論可能なのでアノテーションする必要はありません):
+あなたは依然としてアノテーションを明示しなければならないことに注意してください。しかし、`getJSON<T>`のシグネチャ`(config) => Promise<T>`は、キータイプを減らすことができます(`loadUsers`の戻り値の型は、TypeScriptが推論可能なのでアノテーションする必要はありません):
 
 ```ts
 type LoadUsersResponse = {
diff --git a/docs/types/index-signatures.md b/docs/types/index-signatures.md
index 8a55ea60c..696d94ce5 100644
--- a/docs/types/index-signatures.md
+++ b/docs/types/index-signatures.md
@@ -105,7 +105,7 @@ console.log((2).toString()); // 2
 
 ### インデックスシグネチャを宣言する
 
-今まで私たちは、TypeScriptに私たちが望むことをさせるために`any`を使ってきました。私たちは、実際にはインデックスシグネチャを明示的に指定できます。例えば文字列を使ってオブジェクトに格納されているものが構造体`{message：string}`に従っていることを確認したいとします。これは`{[index：string]：{message：string}}`の宣言で行うことができます。これは以下のとおりです：
+今まで私たちは、TypeScriptに私たちが望むことをさせるために`any`を使ってきました。私たちは、実際にはインデックスシグネチャを明示的に指定できます。例えば文字列を使ってオブジェクトに格納されているものが構造体`{message: string}`に従っていることを確認したいとします。これは`{ [index:string] : {message: string} }`の宣言で行うことができます。これは以下のとおりです：
 
 ```ts
 let foo:{ [index:string] : {message: string} } = {};
@@ -127,9 +127,9 @@ foo['a'].message;
 foo['a'].messages;
 ```
 
-> ヒント： インデックスシグネチャの名前`{[index：string]：{message：string}}`の`index`はTypeScriptにとっては意味がなく、可読性のためだけのものです。例えばもしそれがユーザー名であれば、コードを見る次の開発者のために`{[username：string]：{message：string}}`と宣言することができます。
+> ヒント： インデックスシグネチャの名前`{ [index:string] : {message: string} }`の`index`はTypeScriptにとっては意味がなく、可読性のためだけのものです。例えばもしそれがユーザー名であれば、コードを見る次の開発者のために`{ [username:string] : {message: string} }`と宣言することができます。
 
-もちろん、`number`インデックスもサポートされています。例:`{[count：number]：SomeOtherTypeYouWantToStoreEgRebate}`
+もちろん、`number`インデックスもサポートされています。例:`{ [count: number] : SomeOtherTypeYouWantToStoreEgRebate }`
 
 ### すべてのメンバは`string`インデックスシグネチャに従わなければならない
 
diff --git a/docs/types/lib.d.ts.md b/docs/types/lib.d.ts.md
index 244d746da..6a00f4278 100644
--- a/docs/types/lib.d.ts.md
+++ b/docs/types/lib.d.ts.md
@@ -5,7 +5,7 @@
 * このファイルは、TypeScriptプロジェクトのコンパイルコンテキストに自動的に含まれます
 * このファイルの目的は型チェックのあるJavaScript開発を簡単に始めることです
 
-コンパイルオプションに`--noLib`を指定してこのファイルをコンパイルコンテキストから除外することができます(`tsconfig.json`に`noLib：true`を指定)。
+コンパイルオプションに`--noLib`を指定してこのファイルをコンパイルコンテキストから除外することができます(`tsconfig.json`に`noLib : true`を指定)。
 
 ### 使用例
 
@@ -282,7 +282,7 @@ libsは次のように分類できます。
 ES5にシンボル(Symbol)を含む例：
 
 ターゲットがes5の場合、Symbol APIは含まれません。実際のところ"[ts]Cannot find name 'Symbol'"ようなエラーが表示されます。
-"target"： "es5"と "lib"を組み合わせて、TypeScriptにSymbol APIを提供することができます：
+"target": "es5"と "lib"を組み合わせて、TypeScriptにSymbol APIを提供することができます：
 
 ```json
 "compilerOptions": {
diff --git a/docs/types/literal-types.md b/docs/types/literal-types.md
index 809e2c80a..4827b80c2 100644
--- a/docs/types/literal-types.md
+++ b/docs/types/literal-types.md
@@ -52,7 +52,7 @@ const test = {
 iTakeFoo(test.someProp); // Error: Argument of type string is not assignable to parameter of type 'foo'
 ```
 
-これは、`test`が`{someProp：string} `型であると推定されるためです。この問題を解決するには、シンプルな型アサーションを使用して、TypeScriptに以下のようにリテラルを推測させます。
+これは、`test`が`{someProp: string} `型であると推定されるためです。この問題を解決するには、シンプルな型アサーションを使用して、TypeScriptに以下のようにリテラルを推測させます。
 
 ```js
 function iTakeFoo(foo: 'foo') { }
@@ -67,7 +67,7 @@ iTakeFoo(test.someProp); // Okay!
 
 #### 文字列ベースの列挙型
 
-[TypeScript enumsは数字ベースです](../enums.md)。上記の`CardinalDirection`の例のようにユニオン型の文字列リテラルを使用して文字列ベースの列挙型を模倣することができます。次の関数を使って`Key：Value`構造体を生成することさえできます：
+[TypeScript enumsは数字ベースです](../enums.md)。上記の`CardinalDirection`の例のようにユニオン型の文字列リテラルを使用して文字列ベースの列挙型を模倣することができます。次の関数を使って`Key:Value`構造体を生成することさえできます：
 
 ```ts
 /** Utility function to create a K:V from a list of strings */
diff --git a/docs/types/migrating.md b/docs/types/migrating.md
index 3201ba758..28aed5973 100644
--- a/docs/types/migrating.md
+++ b/docs/types/migrating.md
@@ -55,7 +55,7 @@ var bar = 'hey';
 bar = foo(); // Okay!
 ```
 
-> 注意：エラーを抑止することは危険ですが、新しく書いたTypeScriptコードでエラー通知を受けることができます。`// TODO：`コメントを残してほうが良いかもしれません。
+> 注意：エラーを抑止することは危険ですが、新しく書いたTypeScriptコードでエラー通知を受けることができます。`// TODO:`コメントを残してほうが良いかもしれません。
 
 ### サードパーティ製JavaScript
 JavaScriptをTypeScriptに変更することはできますが、世界全体を変更してTypeScriptを使用することはできません。これは、TypeScriptのアンビエント定義のサポートが必要な部分です。最初は`vendor.d.ts`(`.d.ts`拡張子が、これは宣言ファイルであることを指定しています)を作成し、色々と雑多に詰め込むことをオススメします。あるいは、ライブラリに固有のファイルを作成します(例えば、jqueryのための`jquery.d.ts`)。
diff --git a/docs/types/type-compatibility.md b/docs/types/type-compatibility.md
index 7a2f37d20..730f21ea7 100644
--- a/docs/types/type-compatibility.md
+++ b/docs/types/type-compatibility.md
@@ -161,7 +161,7 @@ addEventListener(EventType.Mouse, <(e: Event) => void>((e: MouseEvent) => consol
 addEventListener(EventType.Mouse, (e: number) => console.log(e));
 ```
 
-また、`Array<Child>`を`Array<Base>`(Covariance)に関数として割り当てることもできます。配列のCovarianceは全ての`Array<Child>`関数が`Array<Base>`に代入可能であることを必要とします。例えば`push(t：Child)`は関数パラメータのBivarianceによって`push(t：Base)`に代入可能です。
+また、`Array<Child>`を`Array<Base>`(Covariance)に関数として割り当てることもできます。配列のCovarianceは全ての`Array<Child>`関数が`Array<Base>`に代入可能であることを必要とします。例えば`push(t:Child)`は関数パラメータのBivarianceによって`push(t:Base)`に代入可能です。
 
 これは他の言語から来た人はエラーになると予測するかもしれません。**混乱を招く可能性がありますが、**これはTypeScriptではエラーになりません：
 
diff --git a/docs/types/type-inference.md b/docs/types/type-inference.md
index 86e59614f..fcb200d0c 100644
--- a/docs/types/type-inference.md
+++ b/docs/types/type-inference.md
@@ -64,7 +64,7 @@ iTakeAnAdder((a, b) => {
 
 ## 構造化(Structuring)
 
-これらの単純なルールは、**構造化**(オブジェクトリテラルの作成)の下でも機能します。たとえば、次のような場合、`foo`の型は`{a：number、b：number}`と推論されます。
+これらの単純なルールは、**構造化**(オブジェクトリテラルの作成)の下でも機能します。たとえば、次のような場合、`foo`の型は`{a:number, b:number}`と推論されます。
 
 ```ts
 let foo = {
@@ -168,5 +168,5 @@ function addOne(a) {
 ## `noImplicitAny`
 
 フラグ `noImplicitAny`は、変数の型を推測できない場合(したがって、暗黙の`any`型としてしか持つことができない場合)、エラーを発生させるようにコンパイラに指示します。それによって、次のことが可能です。
-* そうしたい場合は、明示的に`：any`型の注釈を加えることで`any`型にしたい
+* そうしたい場合は、明示的に`: any`型の注釈を加えることで`any`型にしたい
 * 正しいアノテーションを追加することによってコンパイラを助ける
diff --git a/docs/types/type-system.md b/docs/types/type-system.md
index b99d8f9c6..613d0ea61 100644
--- a/docs/types/type-system.md
+++ b/docs/types/type-system.md
@@ -6,7 +6,7 @@
 では、TypeScript型システムの構文から始めましょう。これにより、コード内でこれらのアノテーションをすぐに使用して、その利点を確認することができます。これは後で詳細を掘り下げる準備にもなります。
 
 ## 基本アノテーション
-前述のように、`：TypeAnnotation`構文を使って型アノテーションを書きます。型宣言空間で使用可能なものは、型アノテーションとして使用できます。
+前述のように、`:TypeAnnotation`構文を使って型アノテーションを書きます。型宣言空間で使用可能なものは、型アノテーションとして使用できます。
 
 次の例は、変数、関数パラメータ、および関数戻り値の型アノテーションを示しています。
 
@@ -38,7 +38,7 @@ bool = 'false'; // Error
 ```
 
 ### 配列(Arrays)
-TypeScriptは、配列に専用の構文を提供し、コードにアノテーションを付けて文書化するのを容易にします。構文は、基本的に`[]`を有効な型アノテーションに後置します(例えば `：boolean[]`)。これは通常行う配列操作を安全に行うことを可能にし、誤った型のメンバを割り当てるなどのエラーからあなたを守ります。これは以下のとおりです：
+TypeScriptは、配列に専用の構文を提供し、コードにアノテーションを付けて文書化するのを容易にします。構文は、基本的に`[]`を有効な型アノテーションに後置します(例えば `:boolean[]`)。これは通常行う配列操作を安全に行うことを可能にし、誤った型のメンバを割り当てるなどのエラーからあなたを守ります。これは以下のとおりです：
 
 ```ts
 var boolArray: boolean[];
@@ -78,10 +78,10 @@ name = {           // Error : `second` is the wrong type
 };
 ```
 
-ここでは、アノテーションを`first：string`+`second：string`という新しいアノテーション`Name`にまとめて、個々のメンバの型チェックを行っています。インターフェースはTypeScriptで大きなパワーを持っているので、別途専用のセクションでその利点をどのように活かすかを説明します。
+ここでは、アノテーションを`first: string` + `second: string`という新しいアノテーション`Name`にまとめて、個々のメンバの型チェックを行っています。インターフェースはTypeScriptで大きなパワーを持っているので、別途専用のセクションでその利点をどのように活かすかを説明します。
 
 ### インライン型アノテーション(Inline Type Annotation)
-新しい`interface`を作成するのではなく、構造`：{/* Structure */}`を使って*インライン*で必要なものにアノテーションを付けることができます。前の例を、インライン型で再掲します：
+新しい`interface`を作成するのではなく、構造`:{/* Structure */}`を使って*インライン*で必要なものにアノテーションを付けることができます。前の例を、インライン型で再掲します：
 
 ```ts
 var name: {
@@ -198,7 +198,7 @@ var reversedNums = numArr.reverse();
 reversedNums = ['1', '2']; // Error!
 ```
 
-後で、**アンビエント宣言**(Ambient Declarations)の節で`lib.d.ts`を説明するときに、`Array <T>`インターフェースについてもっと議論します。
+後で、**アンビエント宣言**(Ambient Declarations)の節で`lib.d.ts`を説明するときに、`Array<T>`インターフェースについてもっと議論します。
 
 ## ユニオン型(Union Type)
 JavaScriptでは、プロパティを複数の型のうちの1つにしたいことがよくあります(例:`string`または`number`)。そういった場合、*ユニオン型*(型アノテーションの`|`を使い`string|number`のように書く)が便利です。よくある使用例として、単一のオブジェクトまたはオブジェクトの配列をとることができる関数があげられます。